Languguage OS 2/Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO/language/embedded/68hc11/buf25_as.txt

Text File | 1994-10-20 | 121KB | 4,808 lines

*                  BUFFALO
* "Bit User's Fast Friendly Aid to Logical Operation"
*
* Rev 2.0 - 4/23/85 - added disassembler.
*                   - variables now PTRn and TMPn.
* Rev 2.1 - 4/29/85 - added byte erase to chgbyt routine.
* Rev 2.2 - 5/16/85 - added hooks for evb board - acia
*                     drivers, init and host routines.
*           7/8/85  - fixed dump wraparound problem.
*           7/10/85 - added evm board commands.
*                   - added fill instruction.
*           7/18/85 - added jump to EEPROM.
* Rev 2.3 - 8/22/85 - call targco to disconnect sci from host
*                     in reset routine for evb board.
*           10/3/85 - modified load for download through terminal.
* Rev 2.4 - 7/1/86  - Changed DFLOP address to fix conflicts with
*                     EEPROM.  (was at A000)
* Rev 2.5 - 9/8/86  - Modified to provide additional protection from
*                     program run-away on power down.  Also fixed bugs
*                     in MM and MOVE.  Changed to 1 stop bit from 2.
*
****************************************************
*    Although the information contained herein,    *
*    as well as any information provided relative  *
*    thereto, has been carefully reviewed and is   *
*    believed accurate, Motorola assumes no        *
*    liability arising out of its application or   *
*    use, neither does it convey any license under *
*    its patent rights nor the rights of others.   *
****************************************************

***************
*   EQUATES   *
***************
RAMBS   EQU  $0000      start of ram
REGBS   EQU  $1000      start of registers
ROMBS   EQU  $E000      start of rom
PORTE   EQU  REGBS+$0A  port e
TCNT    EQU  REGBS+$0E  timer count
TOC5    EQU  REGBS+$1E  oc5 reg
TCTL1   EQU  REGBS+$20  timer control 1
TMSK1   EQU  REGBS+$22  timer mask 1
TFLG1   EQU  REGBS+$23  timer flag 1
TMSK2   EQU  REGBS+$24  timer mask 2
BAUD    EQU  REGBS+$2B  sci baud reg
SCCR1   EQU  REGBS+$2C  sci control1 reg
SCCR2   EQU  REGBS+$2D  sci control2 reg
SCSR    EQU  REGBS+$2E  sci status reg
SCDAT   EQU  REGBS+$2F  sci data reg
OPTION  EQU  REGBS+$39  option reg
COPRST  EQU  REGBS+$3A  cop reset reg
PPROG   EQU  REGBS+$3B  ee prog reg
HPRIO   EQU  REGBS+$3C  hprio reg
CONFIG  EQU  REGBS+$3F  config register
DFLOP   EQU  $4000      evb d flip flop
DUART   EQU  $D000      duart address
PORTA   EQU  DUART
PORTB   EQU  DUART+8
ACIA    EQU  $9800      acia address
PROMPT  EQU  '>'
BUFFLNG EQU  35
CTLA    EQU  $01        exit host or assembler
CTLB    EQU  $02        send break to host
CTLW    EQU  $17        wait
CTLX    EQU  $18        abort
DEL     EQU  $7F        abort
EOT     EQU  $04        end of text/table
SWI     EQU  $3F

***************
*     RAM     *
***************
        ORG  $36
*** Buffalo ram space ***
        RMB  20    user stack area
USTACK  RMB  30    monitor stack area
STACK   RMB  1
INBUFF  RMB  BUFFLNG    input buffer
ENDBUFF EQU  *
COMBUFF RMB  8     command buffer
SHFTREG RMB  2     input shift register
BRKTABL RMB  8     breakpoint table
REGS    RMB  9     user's pc,y,x,a,b,c
SP      RMB  2     user's sp
AUTOLF  RMB  1     auto lf flag for i/o
IODEV   RMB  1     0=sci,  1=acia, 2=duartA, 3=duartB
EXTDEV  RMB  1     0=none, 1=acia, 2=duart,
HOSTDEV RMB  1     0=sci,  1=acia,           3=duartB
COUNT   RMB  1     # characters read
PTRMEM  RMB  2     current memory location

*** Buffalo variables - used by: ***
PTR0    RMB  2     main,readbuff,incbuff,AS
PTR1    RMB  2     main,BR,DU,MO,AS
PTR2    RMB  2     DU,GO,MO,AS
PTR3    RMB  2     HO,MO,AS
PTR4    RMB  2     GO,AS
PTR5    RMB  2     AS
PTR6    RMB  2     GO,AS
PTR7    RMB  2     GO,AS
TMP1    RMB  1     main,hexbin,buffarg,termarg
TMP2    RMB  1     GO,HO,AS
TMP3    RMB  1     AS
TMP4    RMB  1     GO,HO,ME,AS

*** Vector jump table ***
JSCI    RMB   3
JSPI    RMB   3
JPAIE   RMB   3
JPAO    RMB   3
JTOF    RMB   3
JTOC5   RMB   3
JTOC4   RMB   3
JTOC3   RMB   3
JTOC2   RMB   3
JTOC1   RMB   3
JTIC3   RMB   3
JTIC2   RMB   3
JTIC1   RMB   3
JRTI    RMB   3
JIRQ    RMB   3
JXIRQ   RMB   3
JSWI    RMB   3
JILLOP  RMB   3
JCOP    RMB   3
JCLM    RMB   3

*****************
*
* ROM starts here *
*
*****************

        ORG  ROMBS

*****************
**  BUFFALO - This is where Buffalo starts
** out of reset.  All initialization is done
** here including determination of where the
** user terminal is (SCI,ACIA, or DUART).
*****************

BUFFALO  LDX  #PORTE
         BRCLR 0,X $01 BUFISIT if bit 0 of port e is 1
         JMP  $B600       then jump to the start of EEPROM
BUFISIT  LDAA #$93
         STAA OPTION      adpu, dly, irqe, cop
         LDAA #$00
         STAA TMSK2       timer pre = %1 for trace
         LDS  #STACK      monitor stack pointer
         JSR  VECINIT
         LDX  #USTACK
         STX  SP          default user stack
         LDAA #$D0
         STAA REGS+8      default user ccr
         LDD  #$3F0D      initial command is ?
         STD  INBUFF
         JSR  BPCLR       clear breakpoints
         CLR  AUTOLF
         INC  AUTOLF      auto cr/lf = on

* Determine type of external comm device - none, or acia *

         CLR  EXTDEV      default is none
         LDAA HPRIO
         ANDA #$20
         BEQ  BUFF2       jump if single chip mode
         LDAA #$03        see if external acia exists
         STAA ACIA        master reset
         LDAA ACIA
         ANDA #$7F        mask irq bit from status register
         BNE  BUFF1       jump if status reg not 0
         LDAA #$12
         STAA ACIA        turn on acia
         LDAA ACIA
         ANDA #$02
         BEQ  BUFF1       jump if tdre not set
         LDAA #$01
         STAA EXTDEV      external device is acia
         BRA  BUFF2

BUFF1    EQU  *           see if duart exists
         LDAA  DUART+$0C  read IRQ vector register
         CMPA  #$0F       should be out of reset
         BNE   BUFF2
         LDAA #$AA
         STAA DUART+$0C   write irq vector register
         LDAA DUART+$0C   read irq vector register
         CMPA #$AA
         BNE  BUFF2
         LDAA #$02
         STAA EXTDEV      external device is duart A

* Find terminal port - SCI or external. *

BUFF2    CLR  IODEV
         JSR  TARGCO    disconnect sci for evb board
         JSR  SIGNON    initialize sci
         LDAA EXTDEV
         BEQ  BUFF3     jump if no external device
         STAA IODEV
         JSR  SIGNON    initialize external device
BUFF3    CLR  IODEV
         JSR  INPUT     get input from sci port
         CMPA #$0D
         BEQ  BUFF4     jump if cr - sci is terminal port
         LDAA EXTDEV
         BEQ  BUFF3     jump if no external device
         STAA IODEV
         JSR  INPUT     get input from external device
         CMPA #$0D
         BEQ  BUFF4     jump if cr - terminal found ext
         BRA  BUFF3

SIGNON   JSR  INIT        initialize device
         LDX  #MSG1       buffalo message
         JSR  OUTSTRG
         RTS

* Determine where host port should be. *

BUFF4    CLR  HOSTDEV     default - host = sci port
         LDAA IODEV
         CMPA #$01
         BEQ  BUFF5       default host if term = acia
         LDAA #$03
         STAA HOSTDEV     else host is duart port b
BUFF5    EQU  *

*****************
**  MAIN - This module reads the user's input into
** a buffer called INBUFF.  The first field (assumed
** to be the command field) is then parsed into a
** second buffer called COMBUFF.  The command table
** is then searched for the contents of COMBUFF and
** if found, the address of the corresponding task
** routine is fetched from the command table.  The
** task is then called as a subroutine so that
** control returns back to here upon completion of
** the task.  Buffalo expects the following format
** for commands:
**     <cmd>[<wsp><arg><wsp><arg>...]<cr>
** [] implies contents optional.
** <wsp> means whitespace character (space,comma,tab).
** <cmd> = command string of 1-8 characters.
** <arg> = Argument particular to the command.
** <cr> = Carriage return signifying end of input string.
*****************
* Prompt user
*do
*   a=input();
*   if(a==(cntlx or del)) continue;
*   elseif(a==backspace)
*      b--;
*      if(b<0) b=0;
*   else
*      if(a==cr && buffer empty)
*         repeat last command;
*      else put a into buffer;
*         check if buffer full;
*while(a != (cr or /)

MAIN     LDS  #STACK    initialize sp every time
         CLR  AUTOLF
         INC  AUTOLF    auto cr/lf = on
         JSR  OUTCRLF
         LDAA #PROMPT   prompt user
         JSR  OUTPUT
         CLRB
MAIN1    JSR  INCHAR    read terminal
         LDX  #INBUFF
         ABX            pointer into buffer
         CMPA #CTLX
         BEQ  MAIN      jump if cntl X
         CMPA #DEL
         BEQ  MAIN      jump if del
         CMPA #$08
         BNE  MAIN2     jump if not bckspc
         DECB
         BLT  MAIN      jump if buffer empty
         BRA  MAIN1
MAIN2    CMPA #$D
         BNE  MAIN3     jump if not cr
         TSTB
         BEQ  COMM0     jump if buffer empty
         STAA ,X        put a in buffer
         BRA  COMM0
MAIN3    STAA ,X        put a in buffer
         INCB
         CMPB #BUFFLNG
         BLE  MAIN4     jump if not long
         LDX  #MSG3     "long"
         JSR  OUTSTRG
         BRA  MAIN
MAIN4    CMPA #'/'
         BNE  MAIN1     jump if not "/"
*        *******************

*****************
*  Parse out and evaluate the command field.
*****************
*Initialize

COMM0    EQU  *
         CLR  TMP1        Enable "/" command
         CLR  SHFTREG
         CLR  SHFTREG+1
         CLRB
         LDX  #INBUFF     ptrbuff[] = inbuff[]
         STX  PTR0
         JSR  WSKIP       find first char

*while((a=readbuff) != (cr or wspace))
*     upcase(a);
*     buffptr[b] = a
*     b++
*     if (b > 8) error(too long);
*     if(a == "/")
*          if(enabled) mslash();
*          else error(command?);
*     else hexbin(a);

COMM1    EQU  *
         JSR  READBUFF  read from buffer
         LDX  #COMBUFF
         ABX
         JSR  UPCASE    convert to upper case
         STAA ,X        put in command buffer
         CMPA #$0D
         BEQ  SRCH      jump if cr
         JSR  WCHEK
         BEQ  SRCH      jump if wspac
         JSR  INCBUFF   move buffer pointer
         INCB
         CMPB #$8
         BLE  COMM2
         LDX  #MSG3     "long"
         JSR  OUTSTRG
         JMP  MAIN

COMM2    EQU  *
         CMPA #'/'
         BNE  COMM4       jump if not "/"
         TST  TMP1
         BNE  COMM3       jump if not enabled
         STAB COUNT
         LDX  #MSLASH
         JMP  EXEC        execute "/"
COMM3    LDX  #MSG8       "command?"
         JSR  OUTSTRG
         JMP  MAIN
COMM4    EQU  *
         JSR  HEXBIN
         BRA  COMM1

*****************
*   Search tables for command.  At this point,
* COMBUFF holds the command field to be executed,
* and B = # of characters in the command field.
* The command table holds the whole command name
* but only the first n characters of the command
* must match what is in COMBUFF where n is the
* number of characters entered by the user.
*****************
*count = b;
*ptr1 = comtabl;
*while(ptr1[0] != end of table)
*   ptr1 = next entry
*   for(b=1; b=count; b++)
*      if(ptr1[b] == combuff[b]) continue;
*      else error(not found);
*   execute task;
*  return();
*return(command not found);

SRCH    STAB COUNT     size of command entered
        LDX  #COMTABL  pointer to table
        STX  PTR1      pointer to next entry
SRCH1   LDX  PTR1
        LDY  #COMBUFF  pointer to command buffer
        LDAB 0,X
        CMPB #$FF
        BNE  SRCH2
        LDX  #MSG2     "command not found"
        JSR  OUTSTRG
        JMP  MAIN
SRCH2   PSHX            compute next table entry
        ADDB #$3
        ABX
        STX  PTR1
        PULX
        CLRB
SRCHLP  INCB            match characters loop
        LDAA 1,X        read table
        CMPA 0,Y        compare to combuff
        BNE  SRCH1      try next entry
        INX             move pointers
        INY
        CMPB COUNT
        BLT  SRCHLP     loop countu1 times
        LDX  PTR1
        DEX
        DEX
        LDX  0,X     jump address from table
EXEC    JSR  0,X     call task as subroutine
        JMP  MAIN
*
*****************
*   UTILITY SUBROUTINES - These routines
* are called by any of the task routines.
*****************
*****************
*  UPCASE(a) - If the contents of A is alpha,
* returns a converted to uppercase.
*****************
UPCASE   CMPA #'a'
         BLT  UPCASE1      jump if < a
         CMPA #'z'
         BGT  UPCASE1      jump if > z
         SUBA #$20         convert
UPCASE1  RTS

*****************
*  BPCLR() - Clear all entries in the
* table of breakpoints.
*****************
BPCLR    LDX  #BRKTABL
         LDAB #8
BPCLR1   CLR  0,X
         INX
         DECB
         BGT  BPCLR1      loop 8 times
         RTS

*****************
*  RPRNT1(x) - Prints name and contents of a single
* user register. On entry X points to name of register
* in reglist.  On exit, a=register name.
*****************
REGLIST  FCC  'PYXABCS'       names
         FCB  0,2,4,6,7,8,9   offset
         FCB  1,1,1,0,0,0,1   size
RPRNT1   LDAA 0,X
         PSHA
         PSHX
         JSR  OUTPUT      name
         LDAA #'-'
         JSR  OUTPUT      dash
         LDAB 7,X         contents offset
         LDAA 14,X        bytesize
         LDX  #REGS       address
         ABX
         TSTA
         BEQ  RPRN2       jump if 1 byte
         JSR  OUT1BYT     2 bytes
RPRN2    JSR  OUT1BSP
         PULX
         PULA
         RTS

*****************
*  RPRINT() - Print the name and contents
* of all the user registers.
*****************
RPRINT   PSHX
         LDX  #REGLIST
RPRI1    JSR  RPRNT1      print name
         INX
         CMPA #'S'        s is last register
         BNE  RPRI1       jump if not done
         PULX
         RTS

*****************
*   HEXBIN(a) - Convert the ASCII character in a
* to binary and shift into shftreg.  Returns value
* in tmp1 incremented if a is not hex.
*****************
HEXBIN  PSHA
        PSHB
        PSHX
        JSR  UPCASE     convert to upper case
        CMPA #'0'
        BLT  HEXNOT     jump if a < $30
        CMPA #'9'
        BLE  HEXNMB     jump if 0-9
        CMPA #'A'
        BLT  HEXNOT     jump if $39> a <$41
        CMPA #'F'
        BGT  HEXNOT     jump if a > $46
        ADDA #$9        convert $A-$F
HEXNMB  ANDA #$0F       convert to binary
        LDX  #SHFTREG
        LDAB #4
HEXSHFT ASL  1,X        2 byte shift through
        ROL  0,X               carry bit
        DECB
        BGT  HEXSHFT    shift 4 times
        ORAA 1,X
        STAA 1,X
        BRA  HEXRTS
HEXNOT  INC  TMP1       indicate not hex
HEXRTS  PULX
        PULB
        PULA
        RTS

*****************
*  BUFFARG() - Build a hex argument from the
* contents of the input buffer. Characters are
* converted to binary and shifted into shftreg
* until a non-hex character is found.  On exit
* shftreg holds the last four digits read, count
* holds the number of digits read, ptrbuff points
* to the first non-hex character read, and A holds
* that first non-hex character.
*****************
*Initialize
*while((a=readbuff()) not hex)
*     hexbin(a);
*return();

BUFFARG  CLR  TMP1        not hex indicator
         CLR  COUNT       # or digits
         CLR  SHFTREG
         CLR  SHFTREG+1
         JSR  WSKIP
BUFFLP   JSR  READBUFF    read char
         JSR  HEXBIN
         TST  TMP1
         BNE  BUFFRTS     jump if not hex
         INC  COUNT
         JSR  INCBUFF     move buffer pointer
         BRA  BUFFLP
BUFFRTS  RTS

*****************
*  TERMARG() - Build a hex argument from the
* terminal.  Characters are converted to binary
* and shifted into shftreg until a non-hex character
* is found.  On exit shftreg holds the last four
* digits read, count holds the number of digits
* read, and A holds the first non-hex character.
*****************
*initialize
*while((a=inchar()) == hex)
*     if(a = cntlx or del)
*          abort;
*     else
*          hexbin(a); countu1++;
*return();

TERMARG  CLR  COUNT
         CLR  SHFTREG
         CLR  SHFTREG+1
TERM0    JSR  INCHAR
         CMPA #CTLX
         BEQ  TERM1     jump if controlx
         CMPA #DEL
         BNE  TERM2     jump if not delete
TERM1    JMP  MAIN      abort
TERM2    CLR  TMP1      hex indicator
         JSR  HEXBIN
         TST  TMP1
         BNE  TERM3     jump if not hex
         INC  COUNT
         BRA  TERM0
TERM3    RTS

*****************
*   CHGBYT() - If shftreg is not empty, put
* contents of shftreg at address in X.  If X
* is an address in EEPROM then program it.
*****************
*if(count != 0)
*   (x) = a;
*   if(((x) != a) && (x == eeprom location))
*      if((x) != $FF) byte erase (x);
*      if(a != $FF) program(x) = a);
*   if((x) != a) error(ROM)
*return;

CHGBYT   TST  COUNT
         BEQ  CHGBYT4   jump if shftreg empty
         LDAA SHFTREG+1
         STAA 0,X       attempt to write
         LDAA 0,X
         CMPA SHFTREG+1
         BEQ  CHGBYT3   jump if it worked
         CPX  #CONFIG
         BEQ  CHGBYT1   jump if config reg
         CPX  #$B600
         BLO  CHGBYT3   jump if not EE
         CPX  #$B7FF
         BHI  CHGBYT3   jump if not EE
CHGBYT1  EQU  *
         LDAA 0,X
         CMPA #$FF
         BEQ  CHGBYT2   jump if already erased
         LDAA #$16      do byte erase
         STAA PPROG
         LDAA #$FF
         STAA 0,X
         LDAA #$17
         BNE  ACL1
         CLRA           fail safe
ACL1     STAA PPROG
         BSR  CHGWAIT
         LDAA #$00
         STAA PPROG     end of byte erase
CHGBYT2  EQU  *
         LDAA SHFTREG+1
         CMPA #$FF
         BEQ  CHGBYT3   jump if no need to program
         LDAA #$02      do byte program
         STAA PPROG
         LDAA SHFTREG+1
         STAA 0,X
         LDAA #$03
         BNE  ACL2
         CLRA           fail safe
ACL2     STAA PPROG
         BSR  CHGWAIT
         LDAA #$00
         STAA PPROG     end of byte program
CHGBYT3  EQU  *
         LDAA ,X
         CMPA SHFTREG+1
         BEQ  CHGBYT4
         PSHX
         LDX  #MSG6     "rom"
         JSR  OUTSTRG
         JSR  OUTCRLF
         PULX
CHGBYT4  EQU  *
         RTS

CHGWAIT  EQU  *         delay 10 ms at E = 2MHz
         PSHX
         LDX  #$0D06
CHGWAIT1 DEX
         BNE  CHGWAIT1
         PULX
         RTS

*****************
*  READBUFF() -  Read the character in INBUFF
* pointed at by ptrbuff into A.  Returns ptrbuff
* unchanged.
*****************
READBUFF PSHX
         LDX  PTR0
         LDAA 0,X
         PULX
         RTS

*****************
*  INCBUFF(), DECBUFF() - Increment or decrement
* ptrbuff.
*****************
INCBUFF  PSHX
         LDX  PTR0
         INX
         BRA  INCDEC
DECBUFF  PSHX
         LDX  PTR0
         DEX
INCDEC   STX  PTR0
         PULX
         RTS

*****************
*  WSKIP() - Read from the INBUFF until a
* non whitespace (space, comma, tab) character
* is found.  Returns ptrbuff pointing to the
* first non-whitespace character and a holds
* that character.
*****************
WSKIP    JSR  READBUFF  read character
         JSR  WCHEK
         BNE  WSKIP1    jump if not wspc
         JSR  INCBUFF   move pointer
         BRA  WSKIP     loop
WSKIP1   RTS

*****************
*  WCHEK(a) - Returns z=1 if a holds a
* whitespace character, else z=0.
*****************
WCHEK    CMPA #$2C      comma
         BEQ  WCHEK1
         CMPA #$20      space
         BEQ  WCHEK1
         CMPA #$09      tab
WCHEK1   RTS

*****************
*   DCHEK(a) - Returns Z=1 if a = whitespace
* or carriage return.  Else returns z=0.
*****************
DCHEK   JSR  WCHEK
        BEQ  DCHEK1     jump if whitespace
        CMPA #$0D
DCHEK1  RTS

*****************
*  CHKABRT() - Checks for a control x or delete
* from the terminal.  If found, the stack is
* reset and the control is transferred to main.
* Note that this is an abnormal termination.
*   If the input from the terminal is a control W
* then this routine keeps waiting until any other
* character is read.
*****************
*a=input();
*if(a=cntl w) wait until any other key;
*if(a = cntl x or del) abort;

CHKABRT  JSR  INPUT
         BEQ  CHK4      jump if no input
         CMPA #CTLW
         BNE  CHK2      jump in not cntlw
CHKABRT1 JSR  INPUT
         BEQ  CHKABRT1  jump if no input
CHK2     CMPA #DEL
         BEQ  CHK3      jump if delete
         CMPA #CTLX
         BEQ  CHK3      jump if control x
         CMPA #CTLA
         BNE  CHK4      jump not control a
CHK3     JMP  MAIN      abort
CHK4     RTS            return

***********************
*  HOSTCO - connect sci to host for evb board.
*  TARGCO - connect sci to target for evb board.
***********************
HOSTCO   PSHA
         LDAA #$01
         STAA DFLOP     send 1 to d-flop
         PULA
         RTS

TARGCO   PSHA
         LDAA #$00
         STAA DFLOP     send 0 to d-flop
         PULA
         RTS

*
**********
*
*     VECINIT - This routine checks for
*        vectors in the RAM table.  All
*        uninitialized vectors are programmed
*        to JMP STOPIT
*
**********
*
VECINIT     LDX  #JSCI    Point to First RAM Vector
         LDY  #STOPIT    Pointer to STOPIT routine
         LDD  #$7E03    A=JMP opcode; B=offset
VECLOOP     CMPA 0,X
         BEQ  VECNEXT    If vector already in
         STAA 0,X       install JMP
         STY  1,X       to STOPIT routine
VECNEXT     ABX        Add 3 to point at next vector
         CPX  #JCLM+3    Done?
         BNE  VECLOOP    If not, continue loop
         RTS
*
STOPIT   LDAA #$50      Stop-enable; IRQ, XIRQ-Off
         TAP
         STOP        You are lost!  Shut down
         JMP  STOPIT    In case continue by XIRQ

**********
*
*   I/O MODULE
*     Communications with the outside world.
* 3 I/O routines (INIT, INPUT, and OUTPUT) call
* drivers specified by IODEV (0=SCI, 1=ACIA,
* 2=DUARTA, 3=DUARTB).
*
**********
*   INIT() - Initialize device specified by iodev.
*********
*
INIT     EQU  *
         PSHA        save registers
         PSHX
         LDAA IODEV
         CMPA #$00
         BNE  INIT1     jump not sci
         JSR  ONSCI     initialize sci
         BRA  INIT4
INIT1    CMPA #$01
         BNE  INIT2     jump not acia
         JSR  ONACIA    initialize acia
         BRA  INIT4
INIT2    LDX  #PORTA
         CMPA #$02
         BEQ  INIT3     jump duart a
         LDX  #PORTB
INIT3    JSR  ONUART    initialize duart
INIT4    PULX         restore registers
         PULA
         RTS

**********
*  INPUT() - Read device. Returns a=char or 0.
*    This routine also disarms the cop.
**********
INPUT    EQU  *
         PSHX
         LDAA #$55    reset cop
         STAA COPRST
         LDAA #$AA
         STAA COPRST
         LDAA IODEV
         BNE  INPUT1    jump not sci
         JSR  INSCI     read sci
         BRA  INPUT4
INPUT1   CMPA #$01
         BNE  INPUT2    jump not acia
         JSR  INACIA    read acia
         BRA  INPUT4
INPUT2   LDX  #PORTA
         CMPA #$02
         BEQ  INPUT3    jump if duart a
         LDX  #PORTB
INPUT3   JSR  INUART    read uart
INPUT4   PULX
         RTS

**********
*   OUTPUT() - Output character in A.
**********

OUTPUT   EQU  *
         PSHA         save registers
         PSHB
         PSHX
         LDAB IODEV
         BNE  OUTPUT1   jump not sci
         JSR  OUTSCI    write sci
         BRA  OUTPUT4
OUTPUT1  CMPB #$01
         BNE  OUTPUT4   jump not acia
         JSR  OUTACIA   write acia
         BRA  OUTPUT4
OUTPUT2  LDX  #PORTA
         CMPB #$02
         BEQ  OUTPUT3   jump if duart a
         LDX  #PORTB
OUTPUT3  JSR  OUTUART   write uart
OUTPUT4  PULX
         PULB
         PULA
         RTS

**********
*   ONUART(port) - Initialize a duart port.
* Sets duart to internal clock, divide by 16,
* 8 data + 1 stop bits.
**********

ONUART   LDAA #$22
         STAA 2,X         reset receiver
         LDAA #$38
         STAA 2,X         reset transmitter
         LDAA #$40
         STAA 2,X         reset error status
         LDAA #$10
         STAA 2,X         reset pointer
         LDAA #$00
         STAA DUART+4     clock source
         LDAA #$00
         STAA DUART+5     interrupt mask
         LDAA #$13
         STAA 0,X         8 data, no parity
         LDAA #$07
         STAA 0,X         1 stop bits
         LDAA #$BB        baud rate (9600)
         STAA 1,X         tx and rcv baud rate
         LDAA #$05
         STAA 2,X         enable tx and rcv
         RTS

**********
*   INUART(port) - Check duart for any input.
**********

INUART   LDAA 1,X         read status
         ANDA #$01        check rdrf
         BEQ  INUART1     jump if no data
         LDAA 3,X         read data
         ANDA #$7F        to mask parity
INUART1  RTS

**********
*   OUTUART(port) - Output the character in a.
*        if autolf=1, transmits cr or lf as crlf.
**********
OUTUART  TST  AUTOLF
         BEQ  OUTUART2    jump if no autolf
         BSR  OUTUART2
         CMPA #$0D
         BNE  OUTUART1
         LDAA #$0A        if cr, output lf
         BRA  OUTUART2
OUTUART1 CMPA #$0A
         BNE  OUTUART3
         LDAA #$0D        if lf, output cr
OUTUART2 LDAB 1,X         check status
         ANDB #$4
         BEQ  OUTUART2    loop until tdre=1
         ANDA #$7F        mask parity
         STAA 3,X         send character
OUTUART3 RTS

**********
*   ONSCI() - Initialize the SCI for 9600
*                 baud at 8 MHz Extal.
**********
ONSCI    LDAA #$30
         STAA BAUD        baud register
         LDAA #$00
         STAA SCCR1
         LDAA #$0C
         STAA SCCR2       enable
         RTS

**********
*   INSCI() - Read from SCI.  Return a=char or 0.
**********
INSCI    LDAA SCSR      read status reg
         ANDA #$20
         BEQ  INSCI1    jump if rdrf=0
         LDAA SCDAT     read data register
         ANDA #$7F      mask parity
INSCI1   RTS

**********
*  OUTSCI() - Output A to sci. IF autolf = 1,
*               cr and lf sent as crlf.
**********
OUTSCI   TST  AUTOLF
         BEQ  OUTSCI2     jump if autolf=0
         BSR  OUTSCI2
         CMPA #$0D
         BNE  OUTSCI1
         LDAA #$0A        if cr, send lf
         BRA  OUTSCI2
OUTSCI1  CMPA #$0A
         BNE  OUTSCI3
         LDAA #$0D        if lf, send cr
OUTSCI2  LDAB SCSR        read status
         BITB #$80
         BEQ  OUTSCI2     loop until tdre=1
         ANDA #$7F        mask parity
         STAA SCDAT       send character
OUTSCI3  RTS

**********
*   ONACIA - Initialize the ACIA for
* 8 data bits, 1 stop bit, divide by 64 clock.
**********
ONACIA   LDX  #ACIA
         LDAA #$03
         STAA 0,X       master reset
         LDAA #$16
         STAA 0,X       setup
         RTS

**********
*   INACIA - Read from the ACIA, Return a=char or 0.
**********
INACIA   LDX  #ACIA
         LDAA 0,X       status
         PSHA
         ANDA #$70      check pe, ov, fe
         PULA
         BEQ  INACIA1   jump - no error
         BSR  ONACIA    reinitialize and try again
         BRA  INACIA
INACIA1  LSRA           check rdrf
         BCS  INACIA2   jump if data
         CLRA           return(no data)
         RTS
INACIA2  LDAA 1,X       read data
         ANDA #$7F      mask parity
         RTS

**********
*  OUTACIA - Output A to acia. IF autolf = 1,
*               cr or lf sent as crlf.
**********
OUTACIA  BSR  OUTACIA3  output char
         TST  AUTOLF
         BEQ  OUTACIA2  jump no autolf
         CMPA #$0D
         BNE  OUTACIA1
         LDAA #$0A
         BSR  OUTACIA3  if cr, output lf
         BRA  OUTACIA2
OUTACIA1 CMPA #$0A
         BNE  OUTACIA2
         LDAA #$0D
         BSR  OUTACIA3  if lf, output cr
OUTACIA2 RTS

OUTACIA3 LDX  #ACIA
         LDAB 0,X
         BITB #$2
         BEQ  OUTACIA3  loop until tdre
         ANDA #$7F      mask parity
         STAA 1,X       output
         RTS
*
*     Space for modifying OUTACIA routine
*
     FDB  $FFFF,$FFFF,$FFFF,$FFFF
*******************************
*** I/O UTILITY SUBROUTINES ***
***These subroutines perform the neccesary
* data I/O operations.
* OUTLHLF-Convert left 4 bits of A from binary
*            to ASCII and output.
* OUTRHLF-Convert right 4 bits of A from binary
*            to ASCII and output.
* OUT1BYT-Convert byte addresed by X from binary
*           to ASCII and output.
* OUT1BSP-Convert byte addressed by X from binary
*           to ASCII and output followed by a space.
* OUT2BSP-Convert 2 bytes addressed by X from binary
*            to ASCII and  output followed by a space.
* OUTSPAC-Output a space.
*
* OUTCRLF-Output a line feed and carriage return.
*
* OUTSTRG-Output the string of ASCII bytes addressed
*            by X until $04.
* OUTA-Output the ASCII character in A.
*
* INCHAR-Input to A and echo one character.  Loops
*            until character read.
*        *******************

**********
*  OUTRHLF(), OUTLHLF(), OUTA()
*Convert A from binary to ASCII and output.
*Contents of A are destroyed..
**********
OUTLHLF  LSRA            shift data to right
         LSRA
         LSRA
         LSRA
OUTRHLF  ANDA #$0F       mask top half
         ADDA #$30       convert to ascii
         CMPA #$39
         BLE  OUTA       jump if 0-9
         ADDA #$07       convert to hex A-F
OUTA     JSR  OUTPUT     output character
         RTS

**********
*  OUT1BYT(x) - Convert the byte at X to two
* ASCII characters and output. Return X pointing
* to next byte.
**********
OUT1BYT  PSHA
         LDAA 0,X        get data in a
         PSHA            save copy
         BSR  OUTLHLF    output left half
         PULA            retrieve copy
         BSR  OUTRHLF    output right half
         PULA
         INX
         RTS

**********
*  OUT1BSP(x), OUT2BSP(x) - Output 1 or 2 bytes
* at x followed by a space.  Returns x pointing to
* next byte.
**********
OUT2BSP  JSR  OUT1BYT      do first byte
OUT1BSP  JSR  OUT1BYT      do next byte
OUTSPAC  LDAA #$20         output a space
         JSR  OUTPUT
         RTS

**********
*  OUTCRLF() - Output a Carriage return and
* a line feed.  Returns a = cr.
**********
OUTCRLF  LDAA #$0D      cr
         JSR  OUTPUT    output a
         LDAA #$00
         JSR  OUTPUT    output padding
         LDAA #$0D
         RTS

**********
*  OUTSTRG(x) - Output string of ASCII bytes
* starting at x until end of text ($04).  Can
* be paused by control w (any char restarts).
**********
OUTSTRG  JSR  OUTCRLF
OUTSTRG0 PSHA
OUTSTRG1 LDAA 0,X          read char into a
         CMPA #EOT
         BEQ  OUTSTRG3     jump if eot
         JSR  OUTPUT       output character
         INX
         JSR  INPUT
         BEQ  OUTSTRG1     jump if no input
         CMPA #CTLW
         BNE  OUTSTRG1     jump if not cntlw
OUTSTRG2 JSR  INPUT
         BEQ  OUTSTRG2     jump if any input
         BRA  OUTSTRG1
OUTSTRG3 PULA
         RTS

**********
*  INCHAR() - Reads input until character sent.
*    Echoes char and returns with a = char.
INCHAR   JSR  INPUT
         TSTA
         BEQ  INCHAR      jump if no input
         JSR  OUTPUT      echo
         RTS

*********************
*** COMMAND TABLE ***
COMTABL  EQU  *
         FCB  5
         FCC  'ASSEM'
         FDB  #ASSEM
         FCB  5
         FCC  'BREAK'
         FDB  #BREAK
         FCB  4
         FCC  'BULK'
         FDB  #BULK
         FCB  7
         FCC  'BULKALL'
         FDB  #BULKALL
         FCB  4
         FCC  'CALL'
         FDB  #CALL
         FCB  4
         FCC  'DUMP'
         FDB  #DUMP
         FCB  4
         FCC  'FILL'
         FDB  #FILL
         FCB  2
         FCC  'GO'
         FDB  #GO
         FCB  4
         FCC  'HELP'
         FDB  #HELP
         FCB  4
         FCC  'HOST'
         FDB  #HOST
         FCB  4
         FCC  'LOAD'
         FDB  #LOAD
         FCB  6          LENGTH OF COMMAND
         FCC  'MEMORY'   ASCII COMMAND
         FDB  #MEMORY    COMMAND ADDRESS
         FCB  4
         FCC  'MOVE'
         FDB  #MOVE
         FCB  7
         FCC  'PROCEED'
         FDB  #PROCEED
         FCB  8
         FCC  'REGISTER'
         FDB  #REGISTER
         FCB  5
         FCC  'TRACE'
         FDB  #TRACE
         FCB  6
         FCC  'VERIFY'
         FDB  #VERIFY
         FCB  1
         FCC  '?'       initial command
         FDB  #HELP
         FCB  5
         FCC  'XBOOT'
         FDB  #BOOT
*
*** Command names for evm compatability ***
*
         FCB  3
         FCC  'ASM'
         FDB  #ASSEM
         FCB  2
         FCC  'BF'
         FDB  #FILL
         FCB  4
         FCC  'COPY'
         FDB  #MOVE
         FCB  5
         FCC  'ERASE'
         FDB  #BULK
         FCB  2
         FCC  'MD'
         FDB  #DUMP
         FCB  2
         FCC  'MM'
         FDB  #MEMORY
         FCB  2
         FCC  'RD'
         FDB  #REGISTER
         FCB  2
         FCC  'RM'
         FDB  #REGISTER
         FCB  4
         FCC  'READ'
         FDB  #MOVE
         FCB  2
         FCC  'TM'
         FDB  #HOST
         FCB  4
         FCC  'TEST'
         FDB  #EVBTEST
         FCB  -1

*******************
*** TEXT TABLES ***

MSG1    FCC   'BUFFALO 2.5 (ext) - Bit User Fast Friendly Aid to Logical Operation'
        FCB   EOT
MSG2    FCC   'What?'
        FCB   EOT
MSG3    FCC   'Too Long'
        FCB   EOT
MSG4    FCC   'Full'
        FCB   EOT
MSG5    FCC   'Op- '
        FCB   EOT
MSG6    FCC   'rom-'
        FCB   EOT
MSG8    FCC   'Command?'
        FCB   EOT
MSG9    FCC   'Bad argument'
        FCB   EOT
MSG10   FCC   'No host port available'
        FCB   EOT
MSG11   FCC   'done'
        FCB   EOT
MSG12   FCC   'checksum error'
        FCB   EOT
MSG13   FCC   'error addr '
        FCB   EOT

**********
*   break [-][<addr>] . . .
* Modifies the breakpoint table.  More than
* one argument can be entered on the command
* line but the table will hold only 4 entries.
* 4 types of arguments are implied above:
* break           Prints table contents.
* break <addr>    Inserts <addr>.
* break -<addr>   Deletes <addr>.
* break -         Clears all entries.
**********
* while 1
*     a = wskip();
*     switch(a)
*          case(cr):
*               bprint(); return;

BREAK   JSR  WSKIP
        CMPA #$0D
        BNE  BRKDEL     jump if not cr
        JSR  BPRINT     print table
        RTS

*          case("-"):
*               incbuff(); readbuff();
*               if(dchek(a))          /* look for wspac or cr */
*                    bpclr();
*                    breaksw;
*               a = buffarg();
*               if( !dchek(a) ) return(bad argument);
*               b = bpsrch();
*               if(b >= 0)
*                    brktabl[b] = 0;
*               breaksw;

BRKDEL  CMPA #'-'
        BNE  BRKDEF     jump if not -
        JSR  INCBUFF
        JSR  READBUFF
        JSR  DCHEK
        BNE  BRKDEL1    jump if not delimeter
        JSR  BPCLR      clear table
        JMP  BREAK      do next argument
BRKDEL1 JSR  BUFFARG    get address to delete
        JSR  DCHEK
        BEQ  BRKDEL2    jump if delimeter
        LDX  #MSG9      "bad argument"
        JSR  OUTSTRG
        RTS
BRKDEL2 JSR  BPSRCH     look for addr in table
        TSTB
        BMI  BRKDEL3    jump if not found
        LDX  #BRKTABL
        ABX
        CLR  0,X        clear entry
        CLR  1,X
BRKDEL3 JMP  BREAK      do next argument

*          default:
*               a = buffarg();
*               if( !dchek(a) ) return(bad argument);
*               b = bpsrch();
*               if(b < 0)            /* not already in table */
*                    x = shftreg;
*                    shftreg = 0;
*                    a = x[0]; x[0] = $3F
*                    b = x[0]; x[0] = a;
*                    if(b != $3F) return(rom);
*                    b = bpsrch();   /* look for hole */
*                    if(b >= 0) return(table full);
*                    brktabl[b] = x;
*               breaksw;

BRKDEF  JSR  BUFFARG    get argument
        JSR  DCHEK
        BEQ  BRKDEF1    jump if delimiter
        LDX  #MSG9      "bad argument"
        JSR  OUTSTRG
        RTS
BRKDEF1 JSR  BPSRCH     look for entry in table
        TSTB
        BGE  BREAK      jump if already in table
        LDX  SHFTREG    x = new entry
        LDAA 0,X
        LDAB #SWI
        STAB 0,X
        LDAB 0,X
        STAA 0,X
        CMPB #SWI
        BEQ  BRKDEF2    jump if writes ok
        STX  PTR1       save address
        LDX  #MSG6      "ROM-"
        JSR  OUTSTRG
        LDX  #PTR1
        JSR  OUT2BSP     print address
        JSR  BPRINT
        RTS
BRKDEF2 CLR  SHFTREG
        CLR  SHFTREG+1
        PSHX
        JSR  BPSRCH     look for 0 entry
        PULX
        TSTB
        BPL  BRKDEF3    jump if table not full
        LDX  #MSG4      "full"
        JSR  OUTSTRG
        JSR  BPRINT
        RTS
BRKDEF3 LDY  #BRKTABL
        ABY
        STX  0,Y        put new entry in
        JMP  BREAK      do next argument

**********
*   bprint() - print the contents of the table.
**********
BPRINT   JSR  OUTCRLF
         LDX  #BRKTABL
         LDAB #4
BPRINT1  JSR  OUT2BSP
         DECB
         BGT  BPRINT1     loop 4 times
         RTS

**********
*   bpsrch() - search table for address in
* shftreg. Returns b = index to entry or
* b = -1 if not found.
**********
*for(b=0; b=6; b=+2)
*     x[] = brktabl + b;
*     if(x[0] = shftreg)
*          return(b);
*return(-1);

BPSRCH   CLRB
BPSRCH1  LDX  #BRKTABL
         ABX
         LDX  0,X       get table entry
         CPX  SHFTREG
         BNE  BPSRCH2   jump if no match
         RTS
BPSRCH2  INCB
         INCB
         CMPB #$6
         BLE  BPSRCH1  loop 4 times
         LDAB #$FF
         RTS


**********
*  bulk  - Bulk erase the eeprom except the
* config register.
**********
BULK    CLR  TMP2
        BRA  BULK1

**********
*  bulkall - Bulk erase the eeprom and the
* config register.
**********
BULKALL CLR  TMP2
        INC  TMP2

*Set up PPROG register for erase
BULK1    PSHA
         LDAA #$06
         STAA PPROG       set eelat, erase bits

*If (EE only) write to $b600
*Else write to config register
         LDAA #$FF
         TST  TMP2
         BNE  BULK2       jump if config
         STAA $B600       write to $b600
         BRA  BULK3
BULK2    STAA CONFIG
BULK3    EQU  *

*Start erasing
         LDAA #$07
         BNE  ACL3
         CLRA           fail safe
ACL3     STAA PPROG

*Delay for 10 ms at E = 2 MHz
         PSHX
         LDX  #$0D06     6~ * 3334 = 20,004 * 0.5 MHz
BULKDLY  DEX            2~
         BNE  BULKDLY   3~
         PULX

*Stop programming
         CLR  PPROG
         PULA
         RTS

**********
*  dump [<addr1> [<addr2>]]  - Dump memory
* in 16 byte lines from <addr1> to <addr2>.
*   Default starting address is "current
* location" and default number of lines is 8.
**********
*ptr1 = ptrmem;        /* default start address */
*ptr2 = ptr1 + $80;    /* default end address */
*a = wskip();
*if(a != cr)
*     a = buffarg();
*     if(countu1 = 0) return(bad argument);
*     if( !dchek(a) ) return(bad argument);
*     ptr1 = shftreg;
*     ptr2 = ptr1 + $80;  /* default end address */
*     a = wskip();
*     if(a != cr)
*          a = buffarg();
*          if(countu1 = 0) return(bad argument);
*          a = wskip();
*          if(a != cr) return(bad argument);
*          ptr2 = shftreg;

DUMP     LDX  PTRMEM    current location
         STX  PTR1      default start
         LDAB #$80
         ABX
         STX  PTR2      default end
         JSR  WSKIP
         CMPA #$D
         BEQ  DUMP1     jump - no arguments
         JSR  BUFFARG   read argument
         TST  COUNT
         BEQ  DUMPERR   jump if no argument
         JSR  DCHEK
         BNE  DUMPERR   jump if delimiter
         LDX  SHFTREG
         STX  PTR1
         LDAB #$80
         ABX
         STX  PTR2      default end address
         JSR  WSKIP
         CMPA #$D
         BEQ  DUMP1     jump - 1 argument
         JSR  BUFFARG   read argument
         TST  COUNT
         BEQ  DUMPERR   jump if no argument
         JSR  WSKIP
         CMPA #$0D
         BNE  DUMPERR   jump if not cr
         LDX  SHFTREG
         STX  PTR2
         BRA  DUMP1     jump - 2 arguments
DUMPERR  LDX  #MSG9     "bad argument"
         JSR  OUTSTRG
         RTS

*ptrmem = ptr1;
*ptr1 = ptr1 & $fff0;

DUMP1    LDD  PTR1
         STD  PTRMEM    new current location
         ANDB #$F0
         STD  PTR1      start dump at 16 byte boundary

*** dump loop starts here ***
*do:
*     output address of first byte;

DUMPLP   JSR  OUTCRLF
         LDX  #PTR1
         JSR  OUT2BSP   first address

*     x = ptr1;
*     for(b=0; b=16; b++)
*          output contents;

         LDX  PTR1      base address
         CLRB           loop counter
DUMPDAT  JSR  OUT1BSP   hex value loop
         INCB
         CMPB #$10
         BLT  DUMPDAT    loop 16 times

*     x = ptr1;
*     for(b=0; b=16; b++)
*          a = x[b];
*          if($7A < a < $20)  a = $20;
*          output ascii contents;

         CLRB           loop counter
DUMPASC  LDX  PTR1      base address
         ABX
         LDAA ,X        ascii value loop
         CMPA #$20
         BLO  DUMP3     jump if non printable
         CMPA #$7A
         BLS  DUMP4     jump if printable
DUMP3    LDAA #$20      space for non printables
DUMP4    JSR  OUTPUT    output ascii value
         INCB
         CMPB #$10
         BLT  DUMPASC   loop 16 times

*     chkabrt();
*     ptr1 = ptr1 + $10;
*while(ptr1 <= ptr2);
*return;

         JSR  CHKABRT   check abort or wait
         LDD  PTR1
         ADDD #$10      point to next 16 byte bound
         STD  PTR1      update ptr1
         CPD  PTR2
         BHI  DUMP5     quit if ptr1 > ptr2
         CPD  #$00      check wraparound at $ffff
         BNE  DUMPLP    jump - no wraparound
         LDD  PTR2
         CPD  #$FFF0
         BLO  DUMPLP    upper bound not at top
DUMP5    RTS            quit

**********
*  fill <addr1> <addr2> [<data>]  - Block fill
*memory from addr1 to addr2 with data.  Data
*defaults to $FF.
**********
*get addr1 and addr2

FILL    EQU  *
        JSR  WSKIP
        JSR  BUFFARG
        TST  COUNT
        BEQ  FILLERR    jump if no argument
        JSR  WCHEK
        BNE  FILLERR    jump if bad argument
        LDX  SHFTREG
        STX  PTR1       address1
        JSR  WSKIP
        JSR  BUFFARG
        TST  COUNT
        BEQ  FILLERR    jump if no argument
        JSR  DCHEK
        BNE  FILLERR    jump if bad argument
        LDX  SHFTREG
        STX  PTR2       address2

*Get data if it exists
        LDAA #$FF
        STAA TMP2       default data
        JSR  WSKIP
        CMPA #$0D
        BEQ  FILL1      jump if default data
        JSR  BUFFARG
        TST  COUNT
        BEQ  FILLERR    jump if no argument
        JSR  WSKIP
        CMPA #$0D
        BNE  FILLERR    jump if bad argument
        LDAA SHFTREG+1
        STAA TMP2

*while(ptr1 <= ptr2)
*   *ptr1 = data
*   if(*ptr1 != data) abort

FILL1   EQU  *
        JSR  CHKABRT    check for abort
        LDX  PTR1       starting address
        LDAA TMP2       data
        STAA 0,X
        CMPA 0,X
        BNE  FILLBAD    jump if no write
        CPX  PTR2
        BEQ  FILL2      quit yet?
        INX
        STX  PTR1
        BRA  FILL1      loop
FILL2   RTS

FILLERR  LDX  #MSG9     "bad argument"
         JSR  OUTSTRG
         RTS

FILLBAD  LDX  #MSG6     "rom -"
         JSR  OUTSTRG
         LDX  #PTR1
         JSR  OUT2BSP
         RTS

**********
*   call [<addr>] - Execute a jsr to addr or
*user's pc value.  Return to monitor by rts
*or breakpoint.
**********
*a = wskip();
*if(a != cr)
*     a = buffarg();
*     a = wskip();
*     if(a != cr) return(bad argument)
*     pc = shftreg;

CALL     JSR  WSKIP
         CMPA #$D
         BEQ  CALL3       jump if no arg
         JSR  BUFFARG
         JSR  WSKIP
         CMPA #$D
         BEQ  CALL2       jump if cr
         LDX  #MSG9       "bad argument"
         JSR  OUTSTRG
         RTS
CALL2    LDX  SHFTREG
         STX  REGS        pc = <addr>

*user_stack[0] = return_to_monitor;
*setbps();
*restack();     /* restack and go*/

CALL3    LDX  SP
         DEX              user stack pointer
         LDD  #RETURN     return address
         STD  0,X
         DEX
         STX  SP          new user stack pointer
         JSR  SETBPS
         CLR  TMP2        flag for breakpoints
         JMP  RESTACK     executes an rti

**********
*   return() - Return here from rts after
*call command.
**********
RETURN   PSHA             save a register
         TPA
         STAA REGS+8      cc register
         PULA
         STD  REGS+6      a and b registers
         STX  REGS+4      x register
         STY  REGS+2      y register
         STS  SP          user stack pointer
         LDS  #STACK      monitor stack pointer
         JSR  REMBPS      remove breakpoints
         JSR  OUTCRLF
         JSR  RPRINT      print user registers
         JMP  MAIN

**********
*   go [<addr>] - Execute starting at <addr> or
*user's pc value.  Executes an rti to user code.
*Returns to monitor via an swi through swiin.
**********
*a = wskip();
*if(a != cr)
*     a = buffarg();
*     a = wskip();
*     if(a != cr) return(bad argument)
*     pc = shftreg;
*setbps();
*restack();     /* restack and go*/

GO       JSR  WSKIP
         CMPA #$0D
         BEQ  GO2         jump if no arg
         JSR  BUFFARG
         JSR  WSKIP
         CMPA #$0D
         BEQ  GO1         jump if cr
         LDX  #MSG9       "bad argument"
         JSR  OUTSTRG
         RTS
GO1      LDX  SHFTREG
         STX  REGS        pc = <addr>
GO2      CLR  TMP2        flag for breakpoints
         INC  TMP2        (1=go, 0=call)
         JSR  SETBPS
         JMP  RESTACK     execute an rti

**********
*   swiin() - return from SWI.  Set up
*stack pointers, save user registers, and
*return to main.
**********
SWIIN    TSX            swi entry point
         LDS  #STACK
         JSR  SAVSTACK save user regs
         LDX  REGS
         DEX
         STX  REGS     save user pc
         LDX  PTR4     restore user swi vector
         STX  JSWI+1

*if(flagt1 = 0) remove return addr from stack;

         TST  TMP2     0=call, 1=go
         BNE  GO3      jump if go command
         LDX  SP       remove return address
         INX
         INX
         STX  SP
GO3      JSR  OUTCRLF  print register values
         JSR  RPRINT
         JSR  REMBPS
         JMP  MAIN     return to monitor
*                      (sp destroyed above)

**********
*   proceed - Same as go except it ignores
*a breakpoint at the first opcode.  Calls
*trace once and the go.
**********
PROCEED  CLR  TMP2       flag for breakpoints
         INC  TMP2       0=trace, 1=proceed
         JMP  TRACE3

**********
*   trace <n> - Trace n instructions starting
*at user's pc value. n is a hex number less than
*$FF (defaults to 1).
**********
*countt1 = 1
*a = wskip();
*if(a != cr)
*     a = buffarg(); a = wskip();
*     if(a != cr) return(bad argument);
*     countt1 = n

TRACE    CLR  TMP4
         INC  TMP4        default countt1 = 1
         CLR  TMP2        0 = trace
         JSR  WSKIP
         CMPA #$0D
         BEQ  TRACE2      jump if cr
         JSR  BUFFARG
         JSR  WSKIP
         CMPA #$0D
         BEQ  TRACE1      jump if cr
         LDX  #MSG9       "bad argument"
         JSR  OUTSTRG
         RTS
TRACE1   LDAA SHFTREG+1   n
         STAA TMP4

*Print opcode
TRACE2   JSR  OUTCRLF
         LDX  #MSG5      "op-"
         JSR  OUTSTRG
         LDX  REGS
         JSR  OUT1BSP    opcode

*Save user OC5 regs, setup monitor OC5 regs
TRACE3   LDAA TCTL1
         STAA PTR2       save user mode/level
         ANDA #$FC
         STAA TCTL1      disable oc5 output
         LDAA TMSK1
         STAA PTR2+1     save user int masks
         CLR  TMSK2      disable tof and pac ints

*Put monitor TOC5 vector into jump table
         LDX  JTOC5+1
         STX  PTR4        save user's vector
         LDAA #$7E        jmp opcode
         STAA JTOC5
         LDX  #TRACEIN
         STX  JTOC5+1     monitor toc5 vector

*Unmask i bit in user ccr
         LDAA REGS+8      user ccr
         ANDA #$EF        clear i bit
         STAA REGS+8

*Arm OC5 interrupt
         LDAB #87        cycles to end of rti
         LDX  TCNT       timer count value
         ABX                                     3~  *
         STX  TOC5       oc5 match register      5~  *
         LDAA #$08                               2~  *
         STAA TFLG1      clear oc5 int flag      4~  *
         STAA TMSK1      enable oc5 interrupt    4~  * 86~
         CLI                                     2~  *
         JMP  RESTACK    execute an rti         66~  *

**********
*   tracein - return from toc5 interrupt.
**********
*Disable toc5 interrupt
*replace user's toc5 vector
TRACEIN  SEI
         CLR  TMSK1      disable timer ints
         TSX
         LDS  #STACK
         JSR  SAVSTACK   save user regs
         LDX  PTR4
         STX  JTOC5+1
         JSR  CHKABRT    check for abort

*if(flagt1 = 1) jump to GO command ( proceed )
         TST  TMP2
         BEQ  TRACE9      jump if trace command
         JMP  GO2

*rprint();
*while(countt1 >= 0) continue trace;

TRACE9   JSR  OUTCRLF     print registers for
         JSR  RPRINT              trace only.
         DEC  TMP4
         BHI  TRACE2      jump if countt1 >= 0
         JMP  MAIN        return to monitor
*                         (sp destroyed above)

**********
*  setbps - Replace user code with swi's at
*breakpoint addresses.
**********
*for(b=0; b=6; b =+ 2)
*     x = brktabl[b];
*     if(x != 0)
*          optabl[b] = x[0];
*          x[0] = $3F;

SETBPS   CLRB
SETBPS1  LDX  #BRKTABL
         LDY  #PTR6
         ABX
         ABY
         LDX  0,X         breakpoint table entry
         BEQ  SETBPS2     jump if 0
         LDAA 0,X         save user opcode
         STAA 0,Y
         LDAA #SWI        insert swi into code
         STAA 0,X
SETBPS2  ADDB #$2
         CMPB #$6
         BLE  SETBPS1     loop 4 times

*Put monitor SWI vector into jump table
         LDX  JSWI+1
         STX  PTR4        save user swi vector
         LDAA #$7E        jmp opcode
         STAA JSWI
         LDX  #SWIIN
         STX  JSWI+1      monitor swi vector
         RTS

**********
*   rembps - Remove breakpoints from user code.
**********
*for(b=0; b=6; b =+ 2)
*     x = brktabl[b];
*     if(x != 0)
*          x[0] = optabl[b];

REMBPS   CLRB
REMBPS1  LDX  #BRKTABL
         LDY  #PTR6
         ABX
         ABY
         LDX  0,X         breakpoint table entry
         BEQ  REMBPS2     jump if 0
         LDAA 0,Y         restore user's opcode
         STAA 0,X
REMBPS2  ADDB #$2
         CMPB #$6
         BLE  REMBPS1     loop 4 times

*Replace user's SWI vector
         LDX  PTR4
         STX  JSWI+1
         RTS

**********
*  restack() - Restore user stack and
*execute an RTI. Extended addressing forced
*to ensure count value for trace.
**********
RESTACK  LDS  >SP        stack pointer
         LDX  >REGS
         PSHX            pc
         LDX  >REGS+2
         PSHX            y
         LDX  >REGS+4
         PSHX            x
         LDD  >REGS+6
         PSHA            a
         PSHB            b
         LDAA >REGS+8
         PSHA            ccr
RESTACK1 RTI

**********
*  savstack() -  Save user's registers.
**********
SAVSTACK LDAA 0,X
         STAA REGS+8      ccr
         LDD  1,X
         STAA REGS+7      b
         STAB REGS+6      a
         LDD  3,X
         STD  REGS+4      x
         LDD  5,X
         STD  REGS+2      y
         LDD  7,X
         STD  REGS        pc
         LDAB #8
         ABX
         STX  SP          stack pointer
         RTS

**********
*   help  -  List buffalo commands to terminal.
**********
HELP     EQU  *
         LDX  #HELPMSG1
         JSR  OUTSTRG    print help screen
         RTS

HELPMSG1 EQU  *
         FCC  'ASM [<addr>]  Line assembler/disassembler.'
         FCB  #$0D
         FCC  '    /        Do same address.           ^        Do previous address.'
         FCB  #$0D
         FCC  '    CTRL-J   Do next address.           RETURN   Do next opcode.'
         FCB  #$0D
         FCC  '    CTRL-A   Quit.'
         FCB  #$0D
         FCC  'BF <addr1> <addr2> [<data>]  Block fill.'
         FCB  #$0D
         FCC  'BR [-][<addr>]  Set up breakpoint table.'
         FCB  #$0D
         FCC  'BULK  Erase the EEPROM.                   BULKALL  Erase EEPROM and CONFIG.'
         FCB  #$0D
         FCC  'CALL [<addr>]  Call user subroutine.      G [<addr>]  Execute user code.'
         FCB  #$0D
         FCC  'LOAD, VERIFY [T] <host download command>  Load or verify S-records.'
         FCB  #$0D
         FCC  'MD [<addr1> [<addr2>]]  Memory dump.'
         FCB  #$0D
         FCC  'MM [<addr>]  Memory modify.'
         FCB  #$0D
         FCC  '    /        Open same address.         CTRL-H or ^   Open previous address.'
         FCB  #$0D
         FCC  '    CTRL-J   Open next address.         SPACE         Open next address.'
         FCB  #$0D
         FCC  '    RETURN   Quit.                      <addr>O       Compute offset to <addr>.'
         FCB  #$0D
         FCC  'MOVE <s1> <s2> [<d>]  Block move.'
         FCB  #$0D
         FCC  'P  Proceed/continue execution.'
         FCB  #$0D
         FCC  'RM [P, Y, X, A, B, C, or S]  Register modify.'
         FCB  #$0D
         FCC  'T [<n>]  Trace n instructions.'
         FCB  #$0D
         FCC  'TM  Transparent mode (CTRL-A = exit, CTRL-B = send break).'
         FCB  #$0D
         FCC  'CTRL-H  Backspace.                      CTRL-W  Wait for any key.'
         FCB  #$0D
         FCC  'CTRL-X or DELETE  Abort/cancel command.'
         FCB  #$0D
         FCC  'RETURN  Repeat last command.'
         FCB  4

**********
*   HOST() - Establishes transparent link between
*       terminal and host.  Port used for host is
*       determined in the reset initialization routine
*       and stored in HOSTDEV.
*          To exit type control A.
*          To send break to host type control B.
*if(no external device) return;
*initialize host port;
*While( !(control A))
*     input(terminal); output(host);
*     input(host); output(terminal);

HOST      LDAA EXTDEV
          BNE  HOST0    jump if host port avail.
          LDX  #MSG10   "no host port avail"
          JSR  OUTSTRG
          RTS
HOST0     CLR  AUTOLF    turn off autolf
          JSR  HOSTCO    connect sci (evb board)
          JSR  HOSTINIT  initialize host port
HOST1     JSR  INPUT     read terminal
          TSTA
          BEQ  HOST3     jump if no char
          CMPA #CTLA
          BEQ  HOSTEND   jump if control a
          CMPA #CTLB
          BNE  HOST2     jump if not control b
          JSR  TXBREAK   send break to host
          BRA  HOST3
HOST2     JSR  HOSTOUT   echo to host
HOST3     JSR  HOSTIN    read host
          TSTA
          BEQ  HOST1     jump if no char
          JSR  OUTPUT    echo to terminal
          BRA  HOST1
HOSTEND   INC  AUTOLF    turn on autolf
          JSR  TARGCO    disconnect sci (evb board)
          RTS            return

**********
* txbreak() - transmit break to host port.
* The duration of the transmitted break is
* approximately 200,000 E-clock cycles, or
* 100ms at 2.0 MHz.
***********
TXBREAK   EQU  *
          LDAA HOSTDEV
          CMPA #$03
          BEQ  TXBDU    jump if duartb is host

TXBSCI    LDX  #SCCR2   sci is host
          BSET 0,X $01  set send break bit
          BSR  TXBWAIT
          BCLR 0,X $01  clear send break bit
          BRA TXB1

TXBDU     LDX  #PORTB   duart host port
          LDAA #$60     start break cmd
          STAA 2,X      port b command register
          BSR  TXBWAIT
          LDAA #$70     stop break cmd
          STAA 2,X      port b command register

TXB1      LDAA #$0D
          JSR  HOSTOUT  send carriage return
          LDAA #$0A
          JSR  HOSTOUT  send linefeed
          RTS

TXBWAIT   LDY  #$6F9B   loop count = 28571
TXBWAIT1  DEY           7 cycle loop
          BNE  TXBWAIT1
          RTS


**********
*   hostinit(), hostin(), hostout() - host i/o
*routines.  Restores original terminal device.
**********
HOSTINIT  LDAB IODEV    save terminal
          PSHB
          LDAB HOSTDEV
          STAB IODEV    point to host
          JSR  INIT     initialize host
          BRA  TERMRES  restore terminal
HOSTIN    LDAB IODEV    save terminal
          PSHB
          LDAB HOSTDEV
          STAB IODEV    point to host
          JSR  INPUT    read host
          BRA  TERMRES  restore terminal
HOSTOUT   LDAB IODEV    save terminal
          PSHB
          LDAB HOSTDEV
          STAB IODEV    point to host
          JSR  OUTPUT   write to host
TERMRES   PULB          restore terminal device
          STAB IODEV
          RTS


**********
*   load(ptrbuff[]) - Load s1/s9 records from
*host to memory.  Ptrbuff[] points to string in
*input buffer which is a command to output s1/s9
*records from the host ("cat filename" for unix).
*    Returns error and address if it can't write
*to a particular location.
**********
*   verify(ptrbuff[]) - Verify memory from load
*command.  Ptrbuff[] is same as for load.
**********
VERIFY    CLR  TMP2
          INC  TMP2      flagt1 = 1 = verify
          BRA  LOAD1
LOAD      CLR  TMP2      flagt1 = 0 = load


*a=wskip();
*if(a = cr) goto transparent mode;
*if(t option) hostdev = iodev;

LOAD1     JSR  WSKIP
          CMPA #$0D
          BNE  LOAD1A
          JMP  HOST      go to host if no args
LOAD1A    JSR  UPCASE
          CMPA #'T       look for t option
          BNE  LOAD1B    jump not t option
          JSR  INCBUFF
          JSR  READBUFF  get next character
          JSR  DECBUFF
          CMPA #$0D
          BNE  LOAD1B    jump if not t option
          CLR  AUTOLF
          LDAA IODEV
          STAA HOSTDEV   set host port = terminal
          BRA  LOAD6     go wait for s1 records

*else while(not cr)
*     read character from input buffer;
*     send character to host;

LOAD1B    CLR  AUTOLF
          JSR  HOSTCO    connect sci (evb board)
          JSR  HOSTINIT  initialize host port
LOAD2     JSR  READBUFF  get next char
          JSR  INCBUFF
          PSHA           save char
          JSR  HOSTOUT   output to host
          JSR  OUTPUT    echo to terminal
          PULA
          CMPA #$0D
          BNE  LOAD2     jump if not cr

*repeat:
*      if(hostdev != iodev) check abort;
*      a = hostin();
*      if(a = 'S')
*          a = hostin;
*          if(a = '9')
*              read rest of record;
*              return(done);
*          if(a = '1')
*              checksum = 0;
*              byte(); b = shftreg+1;     /* byte count */
*              byte(); byte(); x = shftreg; /* base addr*/
*              do
*                  byte();
*                  if(flagt1 = 0)
*                        x[0] = shftreg+1
*                  if(x[0] != shftreg+1)
*                         return("rom-(x)");
*                  x++; b--;
*              until(b = 0)

LOAD6     EQU  *
          LDAA HOSTDEV
          CMPA IODEV
          BEQ  LOAD65    jump if hostdev=iodev
          JSR  CHKABRT   check for abort
LOAD65    JSR  HOSTIN    read host
          TSTA
          BEQ  LOAD6     jump if no input
          CMPA #'S
          BNE  LOAD6     jump if not S
LOAD7     JSR  HOSTIN    read host
          TSTA
          BEQ  LOAD7     jump if no input
          CMPA #'9
          BNE  LOAD8     jump if not S9
          JSR  BYTE
          LDAB SHFTREG+1 b = byte count
LOAD75    JSR  BYTE
          DECB
          BNE  LOAD75    loop until end of record
          INC  AUTOLF    turn on autolf
          JSR  TARGCO    disconnect sci (evb)
          LDX  #MSG11    "done"
          JSR  OUTSTRG
          RTS
LOAD8     CMPA #'1
          BNE  LOAD6     jump if not S1
          CLR  TMP4      clear checksum
          JSR  BYTE
          LDAB SHFTREG+1
          SUBB #$2       b = byte count
          JSR  BYTE
          JSR  BYTE
          LDX  SHFTREG   x = base address
          DEX
LOAD10    JSR  BYTE      get next byte
          INX
          DECB           check byte count
          BEQ  LOAD12    if 0, go do checksum
          LDAA SHFTREG+1
          TST  TMP2
          BNE  LOAD11    jump if verify
          STAA 0,X       load only
LOAD11    CMPA 0,X       verify ram location
          BEQ  LOAD10    jump if ram ok
          STX  PTR3      save error address
          INC  AUTOLF    turn on autolf
          JSR  TARGCO    disconnect sci(evb)
          JSR  OUTCRLF
          LDX  #MSG13    "error addr"
          JSR  OUTSTRG
          LDX  #PTR3
          JSR  OUT2BSP   address
          RTS
LOAD12    LDAA TMP4
          INCA           do checksum
          BNE  LOAD13    jump if s1 record okay
          JMP  LOAD6
LOAD13    INC  AUTOLF
          JSR  TARGCO    disconnect sci(evb)
          JSR  OUTCRLF
          LDX  #MSG12    "checksum error"
          JSR  OUTSTRG
          RTS

**********
*  byte() -  Read 2 ascii bytes from host and
*convert to one hex byte.  Returns byte
*shifted into shftreg and added to tmp4.
**********
BYTE      PSHB
          PSHX
BYTE0     JSR  HOSTIN    read host (1st byte)
          TSTA
          BEQ  BYTE0     loop until input
          JSR  HEXBIN
BYTE1     JSR  HOSTIN    read host (2nd byte)
          TSTA
          BEQ  BYTE1     loop until input
          JSR  HEXBIN
          LDAA SHFTREG+1
          ADDA TMP4
          STAA TMP4      add to checksum
          PULX
          PULB
          RTS


*******************************************
*   MEMORY [<addr>]
*   [<addr>]/
* Opens memory and allows user to modify the
*contents at <addr> or the last opened location.
*    Subcommands:
* [<data>]<cr> - Close current location and exit.
* [<data>]<lf> - Close current and open next.
* [<data>]<^> - Close current and open previous.
* [<data>]<sp> - Close current and open next.
* [<data>]/ - Reopen current location.
*     The contents of the current location is only
*  changed if valid data is entered before each
*  subcommand.
* [<addr>]O - Compute relative offset from current
*     location to <addr>.  The current location must
*     be the address of the offset byte.
**********
*a = wskip();
*if(a != cr)
*     a = buffarg();
*     if(a != cr) return(bad argument);
*     if(countu1 != 0) ptrmem[] = shftreg;

MEMORY   JSR  WSKIP
         CMPA #$D
         BEQ  MEM1      jump if cr
         JSR  BUFFARG
         JSR  WSKIP
         CMPA #$D
         BEQ  MSLASH    jump if cr
         LDX  #MSG9     "bad argument"
         JSR  OUTSTRG
         RTS
MSLASH   TST  COUNT
         BEQ  MEM1      jump if no argument
         LDX  SHFTREG
         STX  PTRMEM    update "current location"

**********
* Subcommands
**********
*outcrlf();
*out2bsp(ptrmem[]);
*out1bsp(ptrmem[0]);

MEM1     JSR  OUTCRLF
MEM2     LDX  #PTRMEM
         JSR  OUT2BSP   output address
MEM3     LDX  PTRMEM
         JSR  OUT1BSP   output contents
         CLR  SHFTREG
         CLR  SHFTREG+1
*while 1
*a = termarg();
*     switch(a)
*          case(space):
*             chgbyt();
*             ptrmem[]++;
*          case(linefeed):
*             chgbyt();
*             ptrmem[]++;
*          case(up arrow):
*          case(backspace):
*               chgbyt();
*               ptrmem[]--;
*          case("/"):
*               chgbyt();
*               outcrlf();
*          case(O):
*               d = ptrmem[0] - (shftreg);
*               if($80 < d < $ff81)
*                    print(out of range);
*               countt1 = d-1;
*               out1bsp(countt1);
*          case(carriage return):
*               chgbyt();
*               return;
*          default: return(command?)

MEM4     JSR  TERMARG
         JSR  UPCASE
         LDX  PTRMEM
         CMPA #$20
         BEQ  MEMSP     jump if space
         CMPA #$0A
         BEQ  MEMLF     jump if linefeed
         CMPA #$5E
         BEQ  MEMUA     jump if up arrow
         CMPA #$08
         BEQ  MEMBS     jump if backspace
         CMPA #'/'
         BEQ  MEMSL     jump if /
         CMPA #'O'
         BEQ  MEMOFF    jump if O
         CMPA #$0D
         BEQ  MEMCR     jump if carriage ret
         LDX  #MSG8     "command?"
         JSR  OUTSTRG
         JMP  MEM1
MEMSP    JSR  CHGBYT
         INX
         STX  PTRMEM
         JMP  MEM3      output contents
MEMLF    JSR  CHGBYT
         INX
         STX  PTRMEM
         JMP  MEM2      output addr, contents
MEMUA    EQU  *
MEMBS    JSR  CHGBYT
         DEX
         STX  PTRMEM
         JMP  MEM1      output cr, addr, contents
MEMSL    JSR  CHGBYT
         JMP  MEM1      output cr, addr, contents
MEMOFF   LDD  SHFTREG   destination addr
         SUBD PTRMEM
         CMPA #$0
         BNE  MEMOFF1   jump if not 0
         CMPB #$80
         BLS  MEMOFF3   jump if in range
         BRA  MEMOFF2   out of range
MEMOFF1  CMPA #$FF
         BNE  MEMOFF2   out of range
         CMPB #$81
         BHS  MEMOFF3   in range
MEMOFF2  LDX  #MSG3     "Too long"
         JSR  OUTSTRG
         JMP  MEM1      output cr, addr, contents
MEMOFF3  SUBD #$1       b now has offset
         STAB TMP4
         JSR  OUTSPAC
         LDX  #TMP4
         JSR  OUT1BSP   output offset
         JMP  MEM1      output cr, addr, contents
MEMCR    JSR  CHGBYT
         RTS            exit task


**********
*   move <src1> <src2> [<dest>]  - move
*block at <src1> to <src2> to <dest>.
*  Moves block 1 byte up if no <dest>.
**********
*a = buffarg();
*if(countu1 = 0) return(bad argument);
*if( !wchek(a) ) return(bad argument);
*ptr1 = shftreg;         /* src1 */

MOVE     EQU  *
         JSR  BUFFARG
         TST  COUNT
         BEQ  MOVERR    jump if no arg
         JSR  WCHEK
         BNE  MOVERR    jump if no delim
         LDX  SHFTREG   src1
         STX  PTR1

*a = buffarg();
*if(countu1 = 0) return(bad argument);
*if( !dchek(a) ) return(bad argument);
*ptr2 = shftreg;         /* src2 */

         JSR  BUFFARG
         TST  COUNT
         BEQ  MOVERR    jump if no arg
         JSR  DCHEK
         BNE  MOVERR    jump if no delim
         LDX  SHFTREG   src2
         STX  PTR2

*a = buffarg();
*a = wskip();
*if(a != cr) return(bad argument);
*if(countu1 != 0) tmp2 = shftreg;  /* dest */
*else tmp2 = ptr1 + 1;

         JSR  BUFFARG
         JSR  WSKIP
         CMPA #$0D
         BNE  MOVERR    jump if not cr
         TST  COUNT
         BEQ  MOVE1     jump if no arg
         LDX  SHFTREG   dest
         BRA  MOVE2
MOVERR   LDX  #MSG9     "bad argument"
         JSR  OUTSTRG
         RTS
MOVE1    LDX  PTR1
         INX            default dest
MOVE2    STX  PTR3

*if(src1 < dest <= src2)
*     dest = dest+(src2-src1);
*     for(x = src2; x = src1; x--)
*          dest[0]-- = x[0]--;

         LDX  PTR3        dest
         CPX  PTR1        src1
         BLS  MOVE3       jump if dest =< src1
         CPX  PTR2        src2
         BHI  MOVE3       jump if dest > src2
         LDD  PTR2
         SUBD PTR1
         ADDD PTR3
         STD  PTR3        dest = dest+(src2-src1)
         LDX  PTR2
MOVELP1  JSR  CHKABRT     check for abort
         LDAA ,X          char at src2
         PSHX
         LDX  PTR3
         CPX  #$B600      jump if not eeprom
         BLO  MOVEA
         CPX  #$B7FF      jump if not eeprom
         BHI  MOVEA
         JSR  MOVPROG     program eeprom
MOVEA    STAA ,X          dest
         DEX
         STX  PTR3
         PULX
         CPX  PTR1
         BEQ  MOVRTS
         DEX
         BRA  MOVELP1     Loop SRC2 - SRC1 times
*
* else
*     for(x=src1; x=src2; x++)
*          dest[0]++ = x[0]++;


MOVE3    LDX  PTR1        srce1
MOVELP2  JSR  CHKABRT     check for abort
         LDAA ,X
         PSHX
         LDX  PTR3        dest
         CPX  #$B600      jump if not eeprom
         BLO  MOVEB
         CPX  #$B7FF      jump if not eeprom
         BHI  MOVEB
         JSR  MOVPROG     program eeprom
MOVEB    STAA ,X
         INX
         STX  PTR3
         PULX
         CPX  PTR2
         BEQ  MOVRTS
         INX
         BRA  MOVELP2      Loop SRC2-SRC1 times
MOVRTS     RTS

*************
*   MOVPROG - Program eeprom location in X with
*       data in A.
*************
MOVPROG  PSHB
         PSHX
         LDAB #$02
         STAB PPROG       set eelat
         STAA ,X
         LDAB #$03
         BNE  ACL4
         CLRB             fail safe
ACL4     STAB PPROG       set pgm
         LDX  #$0D06
MOVEDLY  DEX
         BNE  MOVEDLY     delay 10 ms at E = 2 MHz
         LDAB #$00
         STAB PPROG
         PULX
         PULB
         RTS


**********
*   register [<name>]  - prints the user regs
*and opens them for modification.  <name> is
*the first register opened (default = P).
*   Subcommands:
* [<nn>]<space>  Opens the next register.
* [<nn>]<cr>     Return.
*    The register value is only changed if
*    <nn> is entered before the subcommand.
**********
*x[] = reglist
*a = wskip(); a = upcase(a);
*if(a != cr)
*     while( a != x[0] )
*          if( x[0] = "s") return(bad argument);
*          x[]++;
*     incbuff(); a = wskip();
*     if(a != cr) return(bad argument);

REGISTER LDX  #REGLIST
         JSR  WSKIP       a = first char of arg
         JSR  UPCASE      convert to upper case
         CMPA #$D
         BEQ  REG4        jump if no argument
REG1     CMPA 0,X
         BEQ  REG3
         LDAB 0,X
         INX
         CMPB #'S'
         BNE  REG1        jump if not "s"
REG2     LDX  #MSG9       "bad argument"
         JSR  OUTSTRG
         RTS
REG3     PSHX
         JSR  INCBUFF
         JSR  WSKIP       next char after arg
         CMPA #$D
         PULX
         BNE  REG2        jump if not cr

*rprint();
*     while(x[0] != "s")
*          rprnt1(x);
*          a = termarg();    /* read from terminal */
*          if( ! dchek(a) ) return(bad argument);
*          if(countu1 != 0)
*               if(x[14] = 1)
*                    regs[x[7]++ = shftreg;
*               regs[x[7]] = shftreg+1;
*          if(a = cr) break;
*return;

REG4     JSR  RPRINT      print all registers
REG5     JSR  OUTCRLF
         JSR  RPRNT1      print reg name
         CLR  SHFTREG
         CLR  SHFTREG+1
         JSR  TERMARG     read subcommand
         JSR  DCHEK
         BEQ  REG6        jump if delimeter
         LDX  #MSG9       "bad argument"
         JSR  OUTSTRG
         RTS
REG6     PSHA
         PSHX
         TST  COUNT
         BEQ  REG8        jump if no input
         LDAB 7,X         get reg offset
         LDAA 14,X        byte size
         LDX  #REGS       user registers
         ABX
         TSTA
         BEQ  REG7        jump if 1 byte reg
         LDAA SHFTREG
         STAA 0,X         put in top byte
         INX
REG7     LDAA SHFTREG+1
         STAA 0,X         put in bottom byte
REG8     PULX
         PULA
         LDAB 0,X         CHECK FOR REGISTER S
         CMPB #'S'
         BEQ  REG9        jump if "s"
         INX              point to next register
         CMPA #$D
         BNE  REG5        jump if not cr
REG9     RTS

PAGE1   EQU  $00     values for page opcodes
PAGE2   EQU  $18
PAGE3   EQU  $1A
PAGE4   EQU  $CD
IMMED   EQU  $0      addressing modes
INDX    EQU  $1
INDY    EQU  $2
LIMMED  EQU  $3      (long immediate)
OTHER   EQU  $4

*** Rename variables for assem/disassem ***
AMODE   EQU  TMP2    addressing mode
YFLAG   EQU  TMP3
PNORM   EQU  TMP4    page for normal opcode
OLDPC   EQU  PTRMEM
PC      EQU  PTR1    program counter
PX      EQU  PTR2    page for x indexed
PY      EQU  PTR2+1  page for y indexed
BASEOP  EQU  PTR3    base opcode
CLASS   EQU  PTR3+1  class
DISPC   EQU  PTR4    pc for disassembler
BRADDR  EQU  PTR5    relative branch offset
MNEPTR  EQU  PTR6    pointer to table for dis
ASSCOMM EQU  PTR7    subcommand for assembler

*** Error messages for assembler ***
MSGDIR  FDB  #MSGA1   message table index
        FDB  #MSGA2
        FDB  #MSGA3
        FDB  #MSGA4
        FDB  #MSGA5
        FDB  #MSGA6
        FDB  #MSGA7
        FDB  #MSGA8
        FDB  #MSGA9
MSGA1   FCC  'Immediate mode illegal'
        FCB  EOT
MSGA2   FCC  'Error in mnemonic table'
        FCB  EOT
MSGA3   FCC  'Illegal bit op'
        FCB  EOT
MSGA4   FCC  'Bad argument'
        FCB  EOT
MSGA5   FCC  'Mnemonic not found'
        FCB  EOT
MSGA6   FCC  'Unknown addressing mode'
        FCB  EOT
MSGA7   FCC  'Indexed addressing assumed'
        FCB  EOT
MSGA8   FCC  'Syntax error'
        FCB  EOT
MSGA9   FCC  'Branch out of range'
        FCB  EOT

****************
*  assem(addr) -68HC11 line assembler/disassembler.
*       This routine will disassemble the opcode at
*<addr> and then allow the user to enter a line for
*assembly. Rules for assembly are as follows:
* -A '#' sign indicates immediate addressing.
* -A ',' (comma) indicates indexed addressing
*       and the next character must be X or Y.
* -All arguments are assumed to be hex and the
*       '$' sign shouldn't be used.
* -Arguments should be separated by 1 or more
*       spaces or tabs.
* -Any input after the required number of
*       arguments is ignored.
* -Upper or lower case makes no difference.
*
*       To signify end of input line, the following
*commands are available and have the indicated action:
*   <cr>  -Carriage return finds the next opcode for
*          assembly.  If there was no assembly input,
*          the next opcode disassembled is retrieved
*          from the disassembler.
*   <lf>  -Linefeed works the same as carriage return
*          except if there was no assembly input, the
*          <addr> is incremented and the next <addr> is
*          disassembled.
*    '^'  -Up arrow decrements <addr> and the previous
*          address is then disassembled.
*    '/'  -Slash redisassembles the current address.
*
*       To exit the assembler use CONTROL A.  Of course
*control X and DEL will also allow you to abort.
**********
*oldpc = rambase;
*a = wskip();
*if (a != cr)
*   buffarg()
*   a = wskip();
*   if ( a != cr ) return(error);
*   oldpc = a;

ASSEM   EQU  *
        LDX  #RAMBS
        STX  OLDPC
        JSR  WSKIP
        CMPA #$0D
        BEQ  ASSLOOP jump if no argument
        JSR  BUFFARG
        JSR  WSKIP
        CMPA #$0D
        BEQ  ASSEM1  jump if argument ok
        LDX  #MSGA4  "bad argument"
        JSR  OUTSTRG
        RTS
ASSEM1  LDX  SHFTREG
        STX  OLDPC

*repeat
*  pc = oldpc;
*  out2bsp(pc);
*  disassem();
*  a=readln();
*  asscomm = a;  /* save command */
*  if(a == ('^' or '/')) outcrlf;
*  if(a == 0) return(error);

ASSLOOP LDX  OLDPC
        STX  PC
        JSR  OUTCRLF
        LDX  #PC
        JSR  OUT2BSP   output the address
        JSR  DISASSM   disassemble opcode
        JSR  OUTCRLF
        JSR  OUTSPAC
        JSR  OUTSPAC
        JSR  OUTSPAC
        JSR  OUTSPAC
        LDAA #PROMPT   prompt user
        JSR  OUTA      output prompt character
        JSR  READLN    read input for assembly
        STAA ASSCOMM
        CMPA #'^'
        BEQ  ASSLP0    jump if up arrow
        CMPA #'/'
        BEQ  ASSLP0    jump if slash
        CMPA #$00
        BNE  ASSLP1    jump if none of above
        RTS            return if bad input
ASSLP0  JSR  OUTCRLF
ASSLP1  EQU  *
        JSR  OUTSPAC
        JSR  OUTSPAC
        JSR  OUTSPAC
        JSR  OUTSPAC
        JSR  OUTSPAC

*  b = parse(input); /* get mnemonic */
*  if(b > 5) print("not found"); asscomm='/';
*  elseif(b >= 1)
*     msrch();
*     if(class==$FF)
*        print("not found"); asscomm='/';
*     else
*        a = doop(opcode,class);
*        if(a == 0) dispc=0;
*        else process error; asscomm='/';

        JSR  PARSE
        CMPB #$5
        BLE  ASSLP2  jump if mnemonic <= 5 chars
        LDX  #MSGA5  "mnemonic not found"
        JSR  OUTSTRG
        BRA  ASSLP5
ASSLP2  EQU  *
        CMPB #$0
        BEQ  ASSLP10 jump if no input
        JSR  MSRCH
        LDAA CLASS
        CMPA #$FF
        BNE  ASSLP3
        LDX  #MSGA5  "mnemonic not found"
        JSR  OUTSTRG
        BRA  ASSLP5
ASSLP3  JSR  DOOP
        CMPA #$00
        BNE  ASSLP4  jump if doop error
        LDX  #$00
        STX  DISPC   indicate good assembly
        BRA  ASSLP10
ASSLP4  DECA         a = error message index
        TAB
        LDX  #MSGDIR
        ABX
        ABX
        LDX  0,X
        JSR  OUTSTRG output error message
ASSLP5  CLR  ASSCOMM error command

*  /* compute next address - asscomm holds subcommand
*     and dispc indicates if valid assembly occured. */
*  if(asscomm=='^') oldpc -= 1;
*  if(asscomm==(lf or cr)
*     if(dispc==0) oldpc=pc;
*     else
*        if(asscomm==lf) dispc=oldpc+1;
*        oldpc=dispc;
*until(eot)


ASSLP10 EQU  *
        LDAA ASSCOMM
        CMPA #'^'
        BNE  ASSLP11    jump if not up arrow
        LDX  OLDPC
        DEX
        STX  OLDPC      back up
        BRA  ASSLP15
ASSLP11 CMPA #$0A
        BEQ  ASSLP12    jump if linefeed
        CMPA #$0D
        BNE  ASSLP15    jump if not cr
ASSLP12 LDX  DISPC
        BNE  ASSLP13    jump if dispc != 0
        LDX  PC
        STX  OLDPC
        BRA  ASSLP15
ASSLP13 CMPA #$0A
        BNE  ASSLP14    jump if not linefeed
        LDX  OLDPC
        INX
        STX  DISPC
ASSLP14 LDX  DISPC
        STX  OLDPC
ASSLP15 JMP  ASSLOOP

****************
*  readln() --- Read input from terminal into buffer
* until a command character is read (cr,lf,/,^).
* If more chars are typed than the buffer will hold,
* the extra characters are overwritten on the end.
*  On exit: b=number of chars read, a=0 if quit,
* else a=next command.
****************
*for(b==0;b<=bufflng;b++) inbuff[b] = cr;

READLN  CLRB
        LDAA #$0D    carriage ret
RLN0    LDX  #INBUFF
        ABX
        STAA 0,X     initialize input buffer
        INCB
        CMPB #BUFFLNG
        BLT  RLN0
*b=0;
*repeat
*  if(a == (ctla, cntlc, cntld, cntlx, del))
*     return(a=0);
*  if(a == backspace)
*     if(b > 0) b--;
*     else b=0;
*  else  inbuff[b] = upcase(a);
*  if(b < bufflng) b++;
*until (a == (cr,lf,^,/))
*return(a);

        CLRB
RLN1    JSR  INCHAR
        CMPA #DEL    Delete
        BEQ  RLNQUIT
        CMPA #CTLX   Control X
        BEQ  RLNQUIT
        CMPA #CTLA   Control A
        BEQ  RLNQUIT
        CMPA #$03    Control C
        BEQ  RLNQUIT
        CMPA #$04    Control D
        BEQ  RLNQUIT
        CMPA #$08    backspace
        BNE  RLN2
        DECB
        BGT  RLN1
        BRA  READLN  start over
RLN2    LDX  #INBUFF
        ABX
        JSR  UPCASE
        STAA 0,X     put char in buffer
        CMPB #BUFFLNG        max buffer length
        BGE  RLN3    jump if buffer full
        INCB         move buffer pointer
RLN3    JSR  ASSCHEK check for subcommand
        BNE  RLN1
        RTS
RLNQUIT CLRA         quit
        RTS          return


**********
*  parse() -parse out the mnemonic from INBUFF
* to COMBUFF. on exit: b=number of chars parsed.
**********
*combuff[3] = <space>;   initialize 4th character to space.
*ptrbuff[] = inbuff[];
*a=wskip();
*for (b = 0; b = 5; b++)
*   a=readbuff(); incbuff();
*   if (a = (cr,lf,^,/,wspace)) return(b);
*   combuff[b] = upcase(a);
*return(b);

PARSE   LDAA #$20
        STAA COMBUFF+3
        LDX  #INBUFF         initialize buffer ptr
        STX  PTR0
        JSR  WSKIP           find first character
        CLRB
PARSLP  JSR  READBUFF        read character
        JSR  INCBUFF
        JSR  WCHEK
        BEQ  PARSRT          jump if whitespace
        JSR  ASSCHEK
        BEQ  PARSRT          jump if end of line
        JSR  UPCASE          convert to upper case
        LDX  #COMBUFF
        ABX
        STAA 0,X             store in combuff
        INCB
        CMPB #$5
        BLE  PARSLP          loop 6 times
PARSRT  RTS


****************
*  asschek() -perform compares for
* cr, lf, ^, /
****************
ASSCHEK CMPA #$0A    linefeed
        BEQ  ASSCHK1
        CMPA #$0D    carriage ret
        BEQ  ASSCHK1
        CMPA #'^'    up arrow
        BEQ  ASSCHK1
        CMPA #'/'    slash
ASSCHK1 RTS


*********
*  msrch() --- Search MNETABL for mnemonic in COMBUFF.
*stores base opcode at baseop and class at class.
*  Class = FF if not found.
**********
*while ( != EOF )
*   if (COMBUFF[0-3] = MNETABL[0-3])
*      return(MNETABL[4],MNETABL[5]);
*   else *MNETABL =+ 6

MSRCH   LDX  #MNETABL        pointer to mnemonic table
        LDY  #COMBUFF        pointer to string
        BRA  MSRCH1
MSNEXT  EQU  *
        LDAB #6
        ABX                  point to next table entry
MSRCH1  LDAA 0,X             read table
        CMPA #EOT
        BNE  MSRCH2          jump if not end of table
        LDAA #$FF
        STAA CLASS           FF = not in table
        RTS
MSRCH2  CMPA 0,Y             op[0] = tabl[0] ?
        BNE  MSNEXT
        LDAA 1,X
        CMPA 1,Y             op[1] = tabl[1] ?
        BNE  MSNEXT
        LDAA 2,X
        CMPA 2,Y             op[2] = tabl[2] ?
        BNE  MSNEXT
        LDAA 3,X
        CMPA 3,Y             op[2] = tabl[2] ?
        BNE  MSNEXT
        LDD  4,X             opcode, class
        STAA BASEOP
        STAB CLASS
        RTS

**********
**   doop(baseop,class) --- process mnemonic.
**   on exit: a=error code corresponding to error
**                                     messages.
**********
*amode = OTHER; /* addressing mode */
*yflag = 0;     /* ynoimm, nlimm, and cpd flag */
*x[] = ptrbuff[]

DOOP    EQU  *
        LDAA #OTHER
        STAA AMODE   mode
        CLR  YFLAG
        LDX  PTR0

*while (*x != end of buffer)
*   if (x[0]++ == ',')
*      if (x[0] == 'y') amode = INDY;
*      else amod = INDX;
*      break;
*a = wskip()
*if( a == '#' ) amode = IMMED;

DOPLP1  CPX  #ENDBUFF (end of buffer)
        BEQ  DOOP1   jump if end of buffer
        LDD  0,X     read 2 chars from buffer
        INX          move pointer
        CMPA #','
        BNE  DOPLP1
        CMPB #'Y'    look for ",y"
        BNE  DOPLP2
        LDAA #INDY
        STAA AMODE
        BRA  DOOP1
DOPLP2  CMPB #'X'    look for ",x"
        BNE  DOOP1   jump if not x
        LDAA #INDX
        STAA AMODE
        BRA  DOOP1
DOOP1   JSR  WSKIP
        CMPA #'#'    look for immediate mode
        BNE  DOOP2
        JSR  INCBUFF point at argument
        LDAA #IMMED
        STAA AMODE
DOOP2   EQU  *

*switch(class)
        LDAB CLASS
        CMPB #P2INH
        BNE  DOSW1
        JMP  DOP2I
DOSW1   CMPB #INH
        BNE  DOSW2
        JMP  DOINH
DOSW2   CMPB #REL
        BNE  DOSW3
        JMP  DOREL
DOSW3   CMPB #LIMM
        BNE  DOSW4
        JMP  DOLIM
DOSW4   CMPB #NIMM
        BNE  DOSW5
        JMP  DONOI
DOSW5   CMPB #GEN
        BNE  DOSW6
        JMP  DOGENE
DOSW6   CMPB #GRP2
        BNE  DOSW7
        JMP  DOGRP
DOSW7   CMPB #CPD
        BNE  DOSW8
        JMP  DOCPD
DOSW8   CMPB #XNIMM
        BNE  DOSW9
        JMP  DOXNOI
DOSW9   CMPB #XLIMM
        BNE  DOSW10
        JMP  DOXLI
DOSW10  CMPB #YNIMM
        BNE  DOSW11
        JMP  DOYNOI
DOSW11  CMPB #YLIMM
        BNE  DOSW12
        JMP  DOYLI
DOSW12  CMPB #BTB
        BNE  DOSW13
        JMP  DOBTB
DOSW13  CMPB #SETCLR
        BNE  DODEF
        JMP  DOSET

*   default: return("error in mnemonic table");

DODEF   LDAA #$2
        RTS

*  case P2INH: emit(PAGE2)

DOP2I   LDAA #PAGE2
        JSR  EMIT

*  case INH: emit(baseop);
*       return(0);

DOINH   LDAA BASEOP
        JSR  EMIT
        CLRA
        RTS

*  case REL: a = assarg();
*            if(a=4) return(a);
*            d = address - pc + 2;
*            if ($7f >= d >= $ff82)
*               return (out of range);
*            emit(opcode);
*            emit(offset);
*            return(0);

DOREL   JSR  ASSARG
        CMPA #$04
        BNE  DOREL1  jump if arg ok
        RTS
DOREL1  LDD  SHFTREG get branch address
        LDX  PC      get program counter
        INX
        INX          point to end of opcode
        STX  BRADDR
        SUBD BRADDR  calculate offset
        STD  BRADDR  save result
        CMPD #$7F    in range ?
        BLS  DOREL2  jump if in range
        CMPD #$FF80
        BHS  DOREL2  jump if in range
        LDAA #$09    'Out of range'
        RTS
DOREL2  LDAA BASEOP
        JSR  EMIT    emit opcode
        LDAA BRADDR+1
        JSR  EMIT    emit offset
        CLRA         normal return
        RTS

*  case LIMM: if (amode == IMMED) amode = LIMMED;

DOLIM   LDAA AMODE
        CMPA #IMMED
        BNE  DONOI
        LDAA #LIMMED
        STAA AMODE

*  case NIMM: if (amode == IMMED)
*                return("Immediate mode illegal");

DONOI   LDAA AMODE
        CMPA #IMMED
        BNE  DOGENE  jump if not immediate
        LDAA #$1     "immediate mode illegal"
        RTS

*  case GEN: dogen(baseop,amode,PAGE1,PAGE1,PAGE2);
*            return;

DOGENE  LDAA #PAGE1
        STAA PNORM
        STAA PX
        LDAA #PAGE2
        STAA PY
        JSR  DOGEN
        RTS

*  case GRP2: if (amode == INDY)
*                emit(PAGE2);
*                amode = INDX;
*             if( amode == INDX )
*                doindx(baseop);
*             else a = assarg();
*                if(a=4) return(a);
*                emit(opcode+0x10);
*                emit(extended address);
*             return;

DOGRP   LDAA AMODE
        CMPA #INDY
        BNE  DOGRP1
        LDAA #PAGE2
        JSR  EMIT
        LDAA #INDX
        STAA AMODE
DOGRP1  EQU  *
        LDAA AMODE
        CMPA #INDX
        BNE  DOGRP2
        JSR  DOINDEX
        RTS
DOGRP2  EQU  *
        LDAA BASEOP
        ADDA #$10
        JSR  EMIT
        JSR  ASSARG
        CMPA #$04
        BEQ  DOGRPRT jump if bad arg
        LDD  SHFTREG extended address
        JSR  EMIT
        TBA
        JSR  EMIT
        CLRA
DOGRPRT RTS

*  case CPD: if (amode == IMMED)
*               amode = LIMMED; /* cpd */
*            if( amode == INDY ) yflag = 1;
*            dogen(baseop,amode,PAGE3,PAGE3,PAGE4);
*            return;

DOCPD   LDAA AMODE
        CMPA #IMMED
        BNE  DOCPD1
        LDAA #LIMMED
        STAA AMODE
DOCPD1  LDAA AMODE
        CMPA #INDY
        BNE  DOCPD2
        INC  YFLAG
DOCPD2  LDAA #PAGE3
        STAA PNORM
        STAA PX
        LDAA #PAGE4
        STAA PY
        JSR  DOGEN
        RTS

*  case XNIMM: if (amode == IMMED)      /* stx */
*                 return("Immediate mode illegal");

DOXNOI  LDAA AMODE
        CMPA #IMMED
        BNE  DOXLI
        LDAA #$1     "immediate mode illegal"
        RTS

*  case XLIMM: if (amode == IMMED)  /* cpx, ldx */
*                 amode = LIMMED;
*              dogen(baseop,amode,PAGE1,PAGE1,PAGE4);
*              return;

DOXLI   LDAA AMODE
        CMPA #IMMED
        BNE  DOXLI1
        LDAA #LIMMED
        STAA AMODE
DOXLI1  LDAA #PAGE1
        STAA PNORM
        STAA PX
        LDAA #PAGE4
        STAA PY
        JSR  DOGEN
        RTS

*  case YNIMM: if (amode == IMMED)      /* sty */
*                 return("Immediate mode illegal");

DOYNOI  LDAA AMODE
        CMPA #IMMED
        BNE  DOYLI
        LDAA #$1     "immediate mode illegal"
        RTS

*  case YLIMM: if (amode == INDY) yflag = 1;/* cpy, ldy */
*              if(amode == IMMED) amode = LIMMED;
*              dogen(opcode,amode,PAGE2,PAGE3,PAGE2);
*              return;

DOYLI   LDAA AMODE
        CMPA #INDY
        BNE  DOYLI1
        INC  YFLAG
DOYLI1  CMPA #IMMED
        BNE  DOYLI2
        LDAA #LIMMED
        STAA AMODE
DOYLI2  LDAA #PAGE2
        STAA PNORM
        STAA PY
        LDAA #PAGE3
        STAA PX
        JSR  DOGEN
        RTS

*  case BTB:        /* bset, bclr */
*  case SETCLR: a = bitop(baseop,amode,class);
*               if(a=0) return(a = 3);
*               if( amode == INDY )
*                  emit(PAGE2);
*                  amode = INDX;

DOBTB   EQU  *
DOSET   JSR  BITOP
        CMPA #$00
        BNE  DOSET1
        LDAA #$3     "illegal bit op"
        RTS
DOSET1  LDAA AMODE
        CMPA #INDY
        BNE  DOSET2
        LDAA #PAGE2
        JSR  EMIT
        LDAA #INDX
        STAA AMODE
DOSET2  EQU  *

*               emit(baseop);
*               a = assarg();
*               if(a = 4) return(a);
*               emit(index offset);
*               if( amode == INDX )
*                  Buffptr += 2;      /* skip ,x or ,y */

        LDAA BASEOP
        JSR  EMIT
        JSR  ASSARG
        CMPA #$04
        BNE  DOSET22         jump if arg ok
        RTS
DOSET22 LDAA SHFTREG+1       index offset
        JSR  EMIT
        LDAA AMODE
        CMPA #INDX
        BNE  DOSET3
        JSR  INCBUFF
        JSR  INCBUFF
DOSET3  EQU  *

*               a = assarg();
*               if(a = 4) return(a);
*               emit(mask);   /* mask */
*               if( class == SETCLR )
*                  return;

        JSR  ASSARG
        CMPA #$04
        BNE  DOSET33         jump if arg ok
        RTS
DOSET33 LDAA SHFTREG+1       mask
        JSR  EMIT
        LDAA CLASS
        CMPA #SETCLR
        BNE  DOSET4
        CLRA
        RTS
DOSET4  EQU  *

*               a = assarg();
*               if(a = 4) return(a);
*               d = (pc+1) - shftreg;
*               if ($7f >= d >= $ff82)
*                  return (out of range);
*               emit(branch offset);
*               return(0);

        JSR  ASSARG
        CMPA #$04
        BNE  DOSET5          jump if arg ok
        RTS
DOSET5  LDX  PC              program counter
        INX                  point to next inst
        STX  BRADDR          save pc value
        LDD  SHFTREG         get branch address
        SUBD BRADDR          calculate offset
        CMPD #$7F
        BLS  DOSET6          jump if in range
        CMPD #$FF80
        BHS  DOSET6          jump if in range
        CLRA
        JSR  EMIT
        LDAA #$09            'out of range'
        RTS
DOSET6  TBA                  offset
        JSR  EMIT
        CLRA
        RTS


**********
**   bitop(baseop,amode,class) --- adjust opcode on bit
**       manipulation instructions.  Returns opcode in a
**       or a = 0 if error
**********
*if( amode == INDX || amode == INDY ) return(op);
*if( class == SETCLR ) return(op-8);
*else if(class==BTB) return(op-12);
*else fatal("bitop");

BITOP   EQU  *
        LDAA AMODE
        LDAB CLASS
        CMPA #INDX
        BNE  BITOP1
        RTS
BITOP1  CMPA #INDY
        BNE  BITOP2  jump not indexed
        RTS
BITOP2  CMPB #SETCLR
        BNE  BITOP3  jump not bset,bclr
        LDAA BASEOP  get opcode
        SUBA #8
        STAA BASEOP
        RTS
BITOP3  CMPB #BTB
        BNE  BITOP4  jump not bit branch
        LDAA BASEOP  get opcode
        SUBA #12
        STAA BASEOP
        RTS
BITOP4  CLRA         0 = fatal bitop
        RTS

**********
**   dogen(baseop,mode,pnorm,px,py) - process
** general addressing modes. Returns a = error #.
**********
*pnorm = page for normal addressing modes: IMM,DIR,EXT
*px = page for INDX addressing
*py = page for INDY addressing
*switch(amode)
DOGEN   LDAA AMODE
        CMPA #LIMMED
        BEQ  DOGLIM
        CMPA #IMMED
        BEQ  DOGIMM
        CMPA #INDY
        BEQ  DOGINDY
        CMPA #INDX
        BEQ  DOGINDX
        CMPA #OTHER
        BEQ  DOGOTH

*default: error("Unknown Addressing Mode");

DOGDEF  LDAA #$06        unknown addre...
        RTS

*case LIMMED: epage(pnorm);
*             emit(baseop);
*             a = assarg();
*             if(a = 4) return(a);
*             emit(2 bytes);
*             return(0);

DOGLIM  LDAA PNORM
        JSR  EPAGE
DOGLIM1 LDAA BASEOP
        JSR  EMIT
        JSR  ASSARG   get next argument
        CMPA #$04
        BNE  DOGLIM2   jump if arg ok
        RTS
DOGLIM2 LDD  SHFTREG
        JSR  EMIT
        TBA
        JSR  EMIT
        CLRA
        RTS

*case IMMED: epage(pnorm);
*            emit(baseop);
*            a = assarg();
*            if(a = 4) return(a);
*            emit(lobyte);
*            return(0);

DOGIMM  LDAA PNORM
        JSR  EPAGE
        LDAA BASEOP
        JSR  EMIT
        JSR  ASSARG
        CMPA #$04
        BNE  DOGIMM1   jump if arg ok
        RTS
DOGIMM1 LDAA SHFTREG+1
        JSR  EMIT
        CLRA
        RTS

*case INDY: epage(py);
*           a=doindex(op+0x20);
*           return(a);

DOGINDY LDAA PY
        JSR  EPAGE
        LDAA BASEOP
        ADDA #$20
        STAA BASEOP
        JSR  DOINDEX
        RTS

*case INDX: epage(px);
*           a=doindex(op+0x20);
*           return(a);

DOGINDX LDAA PX
        JSR  EPAGE
        LDAA BASEOP
        ADDA #$20
        STAA BASEOP
        JSR  DOINDEX
        RTS

*case OTHER: a = assarg();
*            if(a = 4) return(a);
*            epage(pnorm);
*            if(countu1 <= 2 digits)   /* direct */
*               emit(op+0x10);
*               emit(lobyte(Result));
*               return(0);
*            else    emit(op+0x30);    /* extended */
*               eword(Result);
*               return(0)

DOGOTH  JSR  ASSARG
        CMPA #$04
        BNE  DOGOTH0  jump if arg ok
        RTS
DOGOTH0 LDAA PNORM
        JSR  EPAGE
        LDAA COUNT
        CMPA #$2
        BGT  DOGOTH1
        LDAA BASEOP
        ADDA #$10            direct mode opcode
        JSR  EMIT
        LDAA SHFTREG+1
        JSR  EMIT
        CLRA
        RTS
DOGOTH1 LDAA BASEOP
        ADDA #$30            extended mode opcode
        JSR  EMIT
        LDD  SHFTREG
        JSR  EMIT
        TBA
        JSR  EMIT
        CLRA
        RTS

**********
**  doindex(op) --- handle all wierd stuff for
**   indexed addressing. Returns a = error number.
**********
*emit(baseop);
*a=assarg();
*if(a = 4) return(a);
*if( a != ',' ) return("Syntax");
*buffptr++
*a=readbuff()
*if( a != 'x' &&  != 'y') warn("Ind Addr Assumed");
*emit(lobyte);
*return(0);

DOINDEX LDAA BASEOP
        JSR  EMIT
        JSR  ASSARG
        CMPA #$04
        BNE  DOINDX0     jump if arg ok
        RTS
DOINDX0 CMPA #','
        BEQ  DOINDX1
        LDAA #$08        "syntax error"
        RTS
DOINDX1 JSR  INCBUFF
        JSR  READBUFF
        CMPA #'Y'
        BEQ  DOINDX2
        CMPA #'X'
        BEQ  DOINDX2
        LDX  MSGA7       "index addr assumed"
        JSR  OUTSTRG
DOINDX2 LDAA SHFTREG+1
        JSR  EMIT
        CLRA
        RTS

**********
**   assarg(); - get argument.  Returns a = 4 if bad
** argument, else a = first non hex char.
**********
*a = buffarg()
*if(asschk(aa) && countu1 != 0) return(a);
*return(bad argument);

ASSARG  JSR  BUFFARG
        JSR  ASSCHEK   check for command
        BEQ  ASSARG1   jump if ok
        JSR  WCHEK     check for whitespace
        BNE  ASSARG2   jump if not ok
ASSARG1 TST  COUNT
        BEQ  ASSARG2   jump if no argument
        RTS
ASSARG2 LDAA #$04      bad argument
        RTS

**********
**  epage(a) --- emit page prebyte
**********
*if( a != PAGE1 ) emit(a);

EPAGE   CMPA #PAGE1
        BEQ  EPAGRT  jump if page 1
        JSR  EMIT
EPAGRT  RTS

**********
*   emit(a) --- emit contents of a
**********
EMIT    LDX  PC
        STAA 0,X
        JSR  OUT1BSP
        STX  PC
        RTS

*Mnemonic table for hc11 line assembler
NULL    EQU  $0      nothing
INH     EQU  $1      inherent
P2INH   EQU  $2      page 2 inherent
GEN     EQU  $3      general addressing
GRP2    EQU  $4      group 2
REL     EQU  $5      relative
IMM     EQU  $6      immediate
NIMM    EQU  $7      general except for immediate
LIMM    EQU  $8      2 byte immediate
XLIMM   EQU  $9      longimm for x
XNIMM   EQU  $10     no immediate for x
YLIMM   EQU  $11     longimm for y
YNIMM   EQU  $12     no immediate for y
BTB     EQU  $13     bit test and branch
SETCLR  EQU  $14     bit set or clear
CPD     EQU  $15     compare d
BTBD    EQU  $16     bit test and branch direct
SETCLRD EQU  $17     bit set or clear direct

**********
*   mnetabl - includes all '11 mnemonics, base opcodes,
* and type of instruction.  The assembler search routine
*depends on 4 characters for each mnemonic so that 3 char
*mnemonics are extended with a space and 5 char mnemonics
*are truncated.
**********

MNETABL EQU  *
        FCC  'ABA '   Mnemonic
        FCB  $1B     Base opcode
        FCB  INH     Class
        FCC  'ABX '
        FCB  $3A
        FCB  INH
        FCC  'ABY '
        FCB  $3A
        FCB  P2INH
        FCC  'ADCA'
        FCB  $89
        FCB  GEN
        FCC  'ADCB'
        FCB  $C9
        FCB  GEN
        FCC  'ADDA'
        FCB  $8B
        FCB  GEN
        FCC  'ADDB'
        FCB  $CB
        FCB  GEN
        FCC  'ADDD'
        FCB  $C3
        FCB  LIMM
        FCC  'ANDA'
        FCB  $84
        FCB  GEN
        FCC  'ANDB'
        FCB  $C4
        FCB  GEN
        FCC  'ASL '
        FCB  $68
        FCB  GRP2
        FCC  'ASLA'
        FCB  $48
        FCB  INH
        FCC  'ASLB'
        FCB  $58
        FCB  INH
        FCC  'ASLD'
        FCB  $05
        FCB  INH
        FCC  'ASR '
        FCB  $67
        FCB  GRP2
        FCC  'ASRA'
        FCB  $47
        FCB  INH
        FCC  'ASRB'
        FCB  $57
        FCB  INH
        FCC  'BCC '
        FCB  $24
        FCB  REL
        FCC  'BCLR'
        FCB  $1D
        FCB  SETCLR
        FCC  'BCS '
        FCB  $25
        FCB  REL
        FCC  'BEQ '
        FCB  $27
        FCB  REL
        FCC  'BGE '
        FCB  $2C
        FCB  REL
        FCC  'BGT '
        FCB  $2E
        FCB  REL
        FCC  'BHI '
        FCB  $22
        FCB  REL
        FCC  'BHS '
        FCB  $24
        FCB  REL
        FCC  'BITA'
        FCB  $85
        FCB  GEN
        FCC  'BITB'
        FCB  $C5
        FCB  GEN
        FCC  'BLE '
        FCB  $2F
        FCB  REL
        FCC  'BLO '
        FCB  $25
        FCB  REL
        FCC  'BLS '
        FCB  $23
        FCB  REL
        FCC  'BLT '
        FCB  $2D
        FCB  REL
        FCC  'BMI '
        FCB  $2B
        FCB  REL
        FCC  'BNE '
        FCB  $26
        FCB  REL
        FCC  'BPL '
        FCB  $2A
        FCB  REL
        FCC  'BRA '
        FCB  $20
        FCB  REL
        FCC  'BRCL'       (BRCLR)
        FCB  $1F
        FCB  BTB
        FCC  'BRN '
        FCB  $21
        FCB  REL
        FCC  'BRSE'       (BRSET)
        FCB  $1E
        FCB  BTB
        FCC  'BSET'
        FCB  $1C
        FCB  SETCLR
        FCC  'BSR '
        FCB  $8D
        FCB  REL
        FCC  'BVC '
        FCB  $28
        FCB  REL
        FCC  'BVS '
        FCB  $29
        FCB  REL
        FCC  'CBA '
        FCB  $11
        FCB  INH
        FCC  'CLC '
        FCB  $0C
        FCB  INH
        FCC  'CLI '
        FCB  $0E
        FCB  INH
        FCC  'CLR '
        FCB  $6F
        FCB  GRP2
        FCC  'CLRA'
        FCB  $4F
        FCB  INH
        FCC  'CLRB'
        FCB  $5F
        FCB  INH
        FCC  'CLV '
        FCB  $0A
        FCB  INH
        FCC  'CMPA'
        FCB  $81
        FCB  GEN
        FCC  'CMPB'
        FCB  $C1
        FCB  GEN
        FCC  'COM '
        FCB  $63
        FCB  GRP2
        FCC  'COMA'
        FCB  $43
        FCB  INH
        FCC  'COMB'
        FCB  $53
        FCB  INH
        FCC  'CPD '
        FCB  $83
        FCB  CPD
        FCC  'CPX '
        FCB  $8C
        FCB  XLIMM
        FCC  'CPY '
        FCB  $8C
        FCB  YLIMM
        FCC  'DAA '
        FCB  $19
        FCB  INH
        FCC  'DEC '
        FCB  $6A
        FCB  GRP2
        FCC  'DECA'
        FCB  $4A
        FCB  INH
        FCC  'DECB'
        FCB  $5A
        FCB  INH
        FCC  'DES '
        FCB  $34
        FCB  INH
        FCC  'DEX '
        FCB  $09
        FCB  INH
        FCC  'DEY '
        FCB  $09
        FCB  P2INH
        FCC  'EORA'
        FCB  $88
        FCB  GEN
        FCC  'EORB'
        FCB  $C8
        FCB  GEN
        FCC  'FDIV'
        FCB  $03
        FCB  INH
        FCC  'IDIV'
        FCB  $02
        FCB  INH
        FCC  'INC '
        FCB  $6C
        FCB  GRP2
        FCC  'INCA'
        FCB  $4C
        FCB  INH
        FCC  'INCB'
        FCB  $5C
        FCB  INH
        FCC  'INS '
        FCB  $31
        FCB  INH
        FCC  'INX '
        FCB  $08
        FCB  INH
        FCC  'INY '
        FCB  $08
        FCB  P2INH
        FCC  'JMP '
        FCB  $6E
        FCB  GRP2
        FCC  'JSR '
        FCB  $8D
        FCB  NIMM
        FCC  'LDAA'
        FCB  $86
        FCB  GEN
        FCC  'LDAB'
        FCB  $C6
        FCB  GEN
        FCC  'LDD '
        FCB  $CC
        FCB  LIMM
        FCC  'LDS '
        FCB  $8E
        FCB  LIMM
        FCC  'LDX '
        FCB  $CE
        FCB  XLIMM
        FCC  'LDY '
        FCB  $CE
        FCB  YLIMM
        FCC  'LSL '
        FCB  $68
        FCB  GRP2
        FCC  'LSLA'
        FCB  $48
        FCB  INH
        FCC  'LSLB'
        FCB  $58
        FCB  INH
        FCC  'LSLD'
        FCB  $05
        FCB  INH
        FCC  'LSR '
        FCB  $64
        FCB  GRP2
        FCC  'LSRA'
        FCB  $44
        FCB  INH
        FCC  'LSRB'
        FCB  $54
        FCB  INH
        FCC  'LSRD'
        FCB  $04
        FCB  INH
        FCC  'MUL '
        FCB  $3D
        FCB  INH
        FCC  'NEG '
        FCB  $60
        FCB  GRP2
        FCC  'NEGA'
        FCB  $40
        FCB  INH
        FCC  'NEGB'
        FCB  $50
        FCB  INH
        FCC  'NOP '
        FCB  $01
        FCB  INH
        FCC  'ORAA'
        FCB  $8A
        FCB  GEN
        FCC  'ORAB'
        FCB  $CA
        FCB  GEN
        FCC  'PSHA'
        FCB  $36
        FCB  INH
        FCC  'PSHB'
        FCB  $37
        FCB  INH
        FCC  'PSHX'
        FCB  $3C
        FCB  INH
        FCC  'PSHY'
        FCB  $3C
        FCB  P2INH
        FCC  'PULA'
        FCB  $32
        FCB  INH
        FCC  'PULB'
        FCB  $33
        FCB  INH
        FCC  'PULX'
        FCB  $38
        FCB  INH
        FCC  'PULY'
        FCB  $38
        FCB  P2INH
        FCC  'ROL '
        FCB  $69
        FCB  GRP2
        FCC  'ROLA'
        FCB  $49
        FCB  INH
        FCC  'ROLB'
        FCB  $59
        FCB  INH
        FCC  'ROR '
        FCB  $66
        FCB  GRP2
        FCC  'RORA'
        FCB  $46
        FCB  INH
        FCC  'RORB'
        FCB  $56
        FCB  INH
        FCC  'RTI '
        FCB  $3B
        FCB  INH
        FCC  'RTS '
        FCB  $39
        FCB  INH
        FCC  'SBA '
        FCB  $10
        FCB  INH
        FCC  'SBCA'
        FCB  $82
        FCB  GEN
        FCC  'SBCB'
        FCB  $C2
        FCB  GEN
        FCC  'SEC '
        FCB  $0D
        FCB  INH
        FCC  'SEI '
        FCB  $0F
        FCB  INH
        FCC  'SEV '
        FCB  $0B
        FCB  INH
        FCC  'STAA'
        FCB  $87
        FCB  NIMM
        FCC  'STAB'
        FCB  $C7
        FCB  NIMM
        FCC  'STD '
        FCB  $CD
        FCB  NIMM
        FCC  'STOP'
        FCB  $CF
        FCB  INH
        FCC  'STS '
        FCB  $8F
        FCB  NIMM
        FCC  'STX '
        FCB  $CF
        FCB  XNIMM
        FCC  'STY '
        FCB  $CF
        FCB  YNIMM
        FCC  'SUBA'
        FCB  $80
        FCB  GEN
        FCC  'SUBB'
        FCB  $C0
        FCB  GEN
        FCC  'SUBD'
        FCB  $83
        FCB  LIMM
        FCC  'SWI '
        FCB  $3F
        FCB  INH
        FCC  'TAB '
        FCB  $16
        FCB  INH
        FCC  'TAP '
        FCB  $06
        FCB  INH
        FCC  'TBA '
        FCB  $17
        FCB  INH
        FCC  'TPA '
        FCB  $07
        FCB  INH
        FCC  'TEST'
        FCB  $00
        FCB  INH
        FCC  'TST '
        FCB  $6D
        FCB  GRP2
        FCC  'TSTA'
        FCB  $4D
        FCB  INH
        FCC  'TSTB'
        FCB  $5D
        FCB  INH
        FCC  'TSX '
        FCB  $30
        FCB  INH
        FCC  'TSY '
        FCB  $30
        FCB  P2INH
        FCC  'TXS '
        FCB  $35
        FCB  INH
        FCC  'TYS '
        FCB  $35
        FCB  P2INH
        FCC  'WAI '
        FCB  $3E
        FCB  INH
        FCC  'XGDX'
        FCB  $8F
        FCB  INH
        FCC  'XGDY'
        FCB  $8F
        FCB  P2INH
        FCC  'BRSE'        bit direct modes for
        FCB  $12             disassembler.
        FCB  BTBD
        FCC  'BRCL'
        FCB  $13
        FCB  BTBD
        FCC  'BSET'
        FCB  $14
        FCB  SETCLRD
        FCC  'BCLR'
        FCB  $15
        FCB  SETCLRD
        FCB  EOT             End of table

**********************************************
PG1     EQU     $0
PG2     EQU     $1
PG3     EQU     $2
PG4     EQU     $3

******************
*disassem() - disassemble the opcode.
******************
*(check for page prebyte)
*baseop=pc[0];
*pnorm=PG1;
*if(baseop==$18) pnorm=PG2;
*if(baseop==$1A) pnorm=PG3;
*if(baseop==$CD) pnorm=PG4;
*if(pnorm != PG1) dispc=pc+1;
*else dispc=pc; (dispc points to next byte)

DISASSM EQU  *
        LDX  PC         address
        LDAA 0,X        opcode
        LDAB #PG1
        CMPA #$18
        BEQ  DISP2      jump if page2
        CMPA #$1A
        BEQ  DISP3      jump if page3
        CMPA #$CD
        BNE  DISP1      jump if not page4
DISP4   INCB            set up page value
DISP3   INCB
DISP2   INCB
        INX
DISP1   STX  DISPC      point to opcode
        STAB PNORM      save page

*If(opcode == ($00-$5F or $8D or $8F or $CF))
*  if(pnorm == (PG3 or PG4))
*      disillop(); return();
*  b=disrch(opcode,NULL);
*  if(b==0) disillop(); return();

        LDAA 0,X  get current opcode
        STAA BASEOP
        INX
        STX  DISPC      point to next byte
        CMPA #$5F
        BLS  DIS1       jump if in range
        CMPA #$8D
        BEQ  DIS1       jump if bsr
        CMPA #$8F
        BEQ  DIS1       jump if xgdx
        CMPA #$CF
        BEQ  DIS1       jump if stop
        JMP  DISGRP     try next part of map
DIS1    LDAB PNORM
        CMPB #PG3
        BLO  DIS2       jump if page 1 or 2
        JSR  DISILLOP   "illegal opcode"
        RTS
DIS2    LDAB BASEOP     opcode
        CLRB            class=null
        JSR  DISRCH
        TSTB
        BNE  DISPEC     jump if opcode found
        JSR  DISILLOP   "illegal opcode"
        RTS

*   if(opcode==$8D) dissrch(opcode,REL);
*   if(opcode==($8F or $CF)) disrch(opcode,INH);

DISPEC  LDAA BASEOP
        CMPA #$8D
        BNE  DISPEC1
        LDAB #REL
        BRA  DISPEC3    look for BSR opcode
DISPEC1 CMPA #$8F
        BEQ  DISPEC2    jump if XGDX opcode
        CMPA #$CF
        BNE  DISINH     jump not STOP opcode
DISPEC2 LDAB #INH
DISPEC3 JSR  DISRCH     find other entry in table

*   if(class==INH)           /* INH */
*      if(pnorm==PG2)
*         b=disrch(baseop,P2INH);
*         if(b==0) disillop(); return();
*      prntmne();
*      return();

DISINH  EQU  *
        LDAB CLASS
        CMPB #INH
        BNE  DISREL     jump if not inherent
        LDAB PNORM
        CMPB #PG1
        BEQ  DISINH1    jump if page1
        LDAA BASEOP     get opcode
        LDAB #P2INH     class=p2inh
        JSR  DISRCH
        TSTB
        BNE  DISINH1    jump if found
        JSR  DISILLOP   "illegal opcode"
        RTS
DISINH1 JSR  PRNTMNE
        RTS

*   elseif(class=REL)       /* REL */
*      if(pnorm != PG1)
*         disillop(); return();
*      prntmne();
*      disrelad();
*      return();

DISREL  EQU  *
        LDAB CLASS
        CMPB #REL
        BNE  DISBTD
        TST  PNORM
        BEQ  DISREL1    jump if page1
        JSR  DISILLOP   "illegal opcode"
        RTS
DISREL1 JSR  PRNTMNE    output mnemonic
        JSR  DISRELAD   compute relative address
        RTS

*   else           /* SETCLR,SETCLRD,BTB,BTBD */
*      if(class == (SETCLRD or BTBD))
*         if(pnorm != PG1)
*            disillop(); return();   /* illop */
*         prntmne();           /* direct */
*         disdir();           /* output $byte */
*      else (class == (SETCLR or BTB))
*         prntmne();           /* indexed */
*         disindx();
*      outspac();
*      disdir();
*      outspac();
*      if(class == (BTB or BTBD))
*         disrelad();
*   return();

DISBTD  EQU  *
        LDAB CLASS
        CMPB #SETCLRD
        BEQ  DISBTD1
        CMPB #BTBD
        BNE  DISBIT     jump not direct bitop
DISBTD1 TST  PNORM
        BEQ  DISBTD2    jump if page 1
        JSR  DISILLOP
        RTS
DISBTD2 JSR  PRNTMNE
        JSR  DISDIR     operand(direct)
        BRA  DISBIT1
DISBIT  EQU  *
        JSR  PRNTMNE
        JSR  DISINDX    operand(indexed)
DISBIT1 JSR  OUTSPAC
        JSR  DISDIR     mask
        LDAB CLASS
        CMPB #BTB
        BEQ  DISBIT2    jump if btb
        CMPB #BTBD
        BNE  DISBIT3    jump if not bit branch
DISBIT2 JSR  DISRELAD   relative address
DISBIT3 RTS


*Elseif($60 <= opcode <= $7F)  /*  GRP2 */
*   if(pnorm == (PG3 or PG4))
*      disillop(); return();
*   if((pnorm==PG2) and (opcode != $6x))
*      disillop(); return();
*   b=disrch(baseop & $6F,NULL);
*   if(b==0) disillop(); return();
*   prntmne();
*   if(opcode == $6x)
*      disindx();
*   else
*      disext();
*   return();

DISGRP  EQU  *
        CMPA #$7F       a=opcode
        BHI  DISNEXT    try next part of map
        LDAB PNORM
        CMPB #PG3
        BLO  DISGRP2    jump if page 1 or 2
        JSR  DISILLOP   "illegal opcode"
        RTS
DISGRP2 ANDA #$6F       mask bit 4
        CLRB            class=null
        JSR  DISRCH
        TSTB
        BNE  DISGRP3    jump if found
        JSR  DISILLOP   "illegal opcode"
        RTS
DISGRP3 JSR  PRNTMNE
        LDAA BASEOP     get opcode
        ANDA #$F0
        CMPA #$60
        BNE  DISGRP4    jump if not 6x
        JSR  DISINDX    operand(indexed)
        RTS
DISGRP4 JSR  DISEXT     operand(extended)
        RTS

*Else  ($80 <= opcode <= $FF)
*   if(opcode == ($87 or $C7))
*      disillop(); return();
*   b=disrch(opcode&$CF,NULL);
*   if(b==0) disillop(); return();

DISNEXT EQU  *
        CMPA #$87       a=opcode
        BEQ  DISNEX1
        CMPA #$C7
        BNE  DISNEX2
DISNEX1 JSR  DISILLOP   "illegal opcode"
        RTS
DISNEX2 ANDA #$CF
        CLRB            class=null
        JSR  DISRCH
        TSTB
        BNE  DISNEW     jump if mne found
        JSR  DISILLOP   "illegal opcode"
        RTS

*   if(opcode&$CF==$8D) disrch(baseop,NIMM; (jsr)
*   if(opcode&$CF==$8F) disrch(baseop,NIMM; (sts)
*   if(opcode&$CF==$CF) disrch(baseop,XNIMM; (stx)
*   if(opcode&$CF==$83) disrch(baseop,LIMM); (subd)

DISNEW  LDAA BASEOP
        ANDA #$CF
        CMPA #$8D
        BNE  DISNEW1    jump not jsr
        LDAB #NIMM
        BRA  DISNEW4
DISNEW1 CMPA #$8F
        BNE  DISNEW2    jump not sts
        LDAB #NIMM
        BRA  DISNEW4
DISNEW2 CMPA #$CF
        BNE  DISNEW3    jump not stx
        LDAB #XNIMM
        BRA  DISNEW4
DISNEW3 CMPA #$83
        BNE  DISGEN     jump not subd
        LDAB #LIMM
DISNEW4 JSR  DISRCH
        TSTB
        BNE  DISGEN     jump if found
        JSR  DISILLOP   "illegal opcode"
        RTS

*   if(class == (GEN or NIMM or LIMM   ))   /* GEN,NIMM,LIMM,CPD */
*      if(opcode&$CF==$83)
*         if(pnorm==(PG3 or PG4)) disrch(opcode#$CF,CPD)
*         class=LIMM;
*      if((pnorm == (PG2 or PG4) and (opcode != ($Ax or $Ex)))
*         disillop(); return();
*      disgenrl();
*      return();

DISGEN  LDAB CLASS      get class
        CMPB #GEN
        BEQ  DISGEN1
        CMPB #NIMM
        BEQ  DISGEN1
        CMPB #LIMM
        BNE  DISXLN     jump if other class
DISGEN1 LDAA BASEOP
        ANDA #$CF
        CMPA #$83
        BNE  DISGEN3    jump if not #$83
        LDAB PNORM
        CMPB #PG3
        BLO  DISGEN3    jump not pg3 or 4
        LDAB #CPD
        JSR  DISRCH     look for cpd mne
        LDAB #LIMM
        STAB CLASS      set class to limm
DISGEN3 LDAB PNORM
        CMPB #PG2
        BEQ  DISGEN4    jump if page 2
        CMPB #PG4
        BNE  #DISGEN5   jump not page 2 or 4
DISGEN4 LDAA BASEOP
        ANDA #$B0       mask bits 6,3-0
        CMPA #$A0
        BEQ  DISGEN5     jump if $Ax or $Ex
        JSR  DISILLOP   "illegal opcode"
        RTS
DISGEN5 JSR  DISGENRL   process general class
        RTS

*   else       /* XLIMM,XNIMM,YLIMM,YNIMM */
*      if(pnorm==(PG2 or PG3))
*         if(class==XLIMM) disrch(opcode&$CF,YLIMM);
*         else disrch(opcode&$CF,YNIMM);
*      if((pnorm == (PG3 or PG4))
*         if(opcode != ($Ax or $Ex))
*            disillop(); return();
*      class=LIMM;
*      disgen();
*   return();

DISXLN  LDAB PNORM
        CMPB #PG2
        BEQ  DISXLN1    jump if page2
        CMPB #PG3
        BNE  DISXLN4    jump not page3
DISXLN1 LDAA BASEOP
        ANDA #$CF
        LDAB CLASS
        CMPB #XLIMM
        BNE  DISXLN2
        LDAB #YLIMM
        BRA  DISXLN3    look for ylimm
DISXLN2 LDAB #YNIMM     look for ynimm
DISXLN3 JSR  DISRCH
DISXLN4 LDAB PNORM
        CMPB #PG3
        BLO  DISXLN5    jump if page 1 or 2
        LDAA BASEOP     get opcode
        ANDA #$B0       mask bits 6,3-0
        CMPA #$A0
        BEQ  DISXLN5    jump opcode = $Ax or $Ex
        JSR  DISILLOP   "illegal opcode"
        RTS
DISXLN5 LDAB #LIMM
        STAB CLASS
        JSR  DISGENRL   process general class
        RTS


******************
*disrch(a=opcode,b=class)
*return b=0 if not found
*  else mneptr=points to mnemonic
*        class=class of opcode
******************
*x=#MNETABL
*while(x[0] != eot)
*   if((opcode==x[4]) && ((class=NULL) || (class=x[5])))
*      mneptr=x;
*      class=x[5];
*      return(1);
*   x += 6;
*return(0);      /* not found */

DISRCH  EQU  *
        LDX  #MNETABL   point to top of table
DISRCH1 CMPA 4,X        test opcode
        BNE  DISRCH3    jump not this entry
        TSTB
        BEQ  DISRCH2    jump if class=null
        CMPB 5,X        test class
        BNE  DISRCH3    jump not this entry
DISRCH2 LDAB 5,X
        STAB CLASS
        STX  MNEPTR     return ptr to mnemonic
        INCB
        RTS             return found
DISRCH3 PSHB            save class
        LDAB #6
        ABX
        LDAB 0,X
        CMPB #EOT       test end of table
        PULB
        BNE  DISRCH1
        CLRB
        RTS             return not found

******************
*prntmne() - output the mnemonic pointed
*at by mneptr.
******************
*outa(mneptr[0-3]);
*outspac;
*return();

PRNTMNE EQU  *
        LDX  MNEPTR
        LDAA 0,X
        JSR  OUTA       output char1
        LDAA 1,X
        JSR  OUTA       output char2
        LDAA 2,X
        JSR  OUTA       output char3
        LDAA 3,X
        JSR  OUTA       output char4
        JSR  OUTSPAC
        RTS

******************
*disindx() - process indexed mode
******************
*disdir();
*outa(',');
*if(pnorm == (PG2 or PG4)) outa('Y');
*else outa('X');
*return();

DISINDX EQU  *
        JSR  DISDIR     output $byte
        LDAA #','
        JSR  OUTA       output ,
        LDAB PNORM
        CMPB #PG2
        BEQ  DISIND1    jump if page2
        CMPB #PG4
        BNE  DISIND2    jump if not page4
DISIND1 LDAA #'Y'
        BRA DISIND3
DISIND2 LDAA #'X'
DISIND3 JSR  OUTA       output x or y
        RTS

******************
*disrelad() - compute and output relative address.
******************
* braddr = dispc[0] + (dispc++);( 2's comp arith)
*outa('$');
*out2bsp(braddr);
*return();

DISRELAD EQU *
        LDX  DISPC
        LDAB 0,X        get relative offset
        INX
        STX  DISPC
        TSTB
        BMI  DISRLD1    jump if negative
        ABX
        BRA  DISRLD2
DISRLD1 DEX
        INCB
        BNE  DISRLD1    subtract
DISRLD2 STX  BRADDR     save address
        JSR  OUTSPAC
        LDAA #'$'
        JSR  OUTA
        LDX  #BRADDR
        JSR  OUT2BSP    output address
        RTS


******************
*disgenrl() - output data for the general cases which
*includes immediate, direct, indexed, and extended modes.
******************
*prntmne();
*if(baseop == ($8x or $Cx))   /* immediate */
*   outa('#');
*   disdir();
*   if(class == LIMM)
*      out1byt(dispc++);
*elseif(baseop == ($9x or $Dx))  /* direct */
*   disdir();
*elseif(baseop == ($Ax or $Ex)) /* indexed */
*   disindx();
*else  (baseop == ($Bx or $Fx)) /* extended */
*   disext();
*return();

DISGENRL EQU *
        JSR  PRNTMNE    print mnemonic
        LDAA BASEOP     get opcode
        ANDA #$B0       mask bits 6,3-0
        CMPA #$80
        BNE  DISGRL2   jump if not immed
        LDAA #'#'       do immediate
        JSR  OUTA
        JSR  DISDIR
        LDAB CLASS
        CMPB #LIMM
        BEQ  DISGRL1   jump class = limm
        RTS
DISGRL1 LDX  DISPC
        JSR  OUT1BYT
        STX  DISPC
        RTS
DISGRL2 CMPA #$90
        BNE  DISGRL3    jump not direct
        JSR  DISDIR     do direct
        RTS
DISGRL3 CMPA #$A0
        BNE  DISGRL4    jump not indexed
        JSR  DISINDX    do extended
        RTS
DISGRL4 JSR  DISEXT     do extended
        RTS

*****************
*disdir() - output "$ next byte"
*****************
DISDIR  EQU  *
        LDAA #'$'
        JSR  OUTA
        LDX  DISPC
        JSR  OUT1BYT
        STX  DISPC
        RTS

*****************
*disext() - output "$ next 2 bytes"
*****************
DISEXT  EQU  *
        LDAA #'$'
        JSR  OUTA
        LDX  DISPC
        JSR  OUT2BSP
        STX  DISPC
        RTS


*****************
*disillop() - output "illegal opcode"
*****************
DISMSG1 FCC  'ILLOP'
        FCB  EOT
DISILLOP EQU *
        PSHX
        LDX  #DISMSG1
        JSR  OUTSTRG0   no cr
        PULX
        RTS

* Equates
JPORTD  EQU   $08
JDDRD   EQU   $09
JBAUD   EQU   $2B
JSCCR1  EQU   $2C
JSCCR2  EQU   $2D
JSCSR   EQU   $2E
JSCDAT  EQU   $2F
*

************
*  boot [<addr>] - Use SCI to talk to an 'hc11 in
* boot mode.  Downloads 256 bytes starting at addr.
* Default addr = $2000.
************

*Get arguments
*If no args, default $2000
BOOT    JSR   WSKIP
        CMPA  #$0D
        BNE   BOT1       jump if arguments
        LDY   #$2000
        BRA   BOT2       go - use default address

*Else get arguments
BOT1    JSR   BUFFARG
        TST   COUNT
        BEQ   BOTERR    jump if no address
        JSR   WSKIP
        LDY   SHFTREG   start address
        CMPA  #$D
        BEQ   BOT2      go - use arguments
BOTERR  LDX   #MSG9     "bad argument"
        JSR   OUTSTRG
        RTS

*Boot routine
BOT2    LDAB  #$FF       control character ($ff -> download)
        JSR   BTSUB      set up SCI and send control char

*Download 256 byte block
        CLRB            counter
BLOP    LDAA  0,Y
        STAA  JSCDAT,X  write to transmitter
        INY
        BRCLR JSCSR,X $80 *      wait for TDRE
        DECB
        BNE   BLOP
        RTS

************************************************
*Subroutine
*  btsub   - sets up SCI and outputs control character
* On entry, B = control character
* On exit,  X = $1000
*           A = $0C
***************************

BTSUB   EQU   *
        LDX   #$1000    to use indexed addressing
        LDAA  #$02
        STAA  JPORTD,X  drive transmitter line
        STAA  JDDRD,X     high
        CLR   JSCCR2,X  turn off XMTR and RCVR
        LDAA  #$22      BAUD = /16
        STAA  JBAUD,X
        LDAA  #$0C      TURN ON XMTR & RCVR
        STAA  JSCCR2,X
        STAB  JSCDAT,X
        BRCLR JSCSR,X $80 *   wait for TDRE
        RTS

******************
*
*    EVBTEST - This routine makes it a little easier
*    on us to test this board.
*
******************

EVBTEST  LDAA  #$FF

         STAA  $1000    Write ones to port A

         CLR  AUTOLF    Turn off auto lf
         JSR  HOSTCO    Connect host
         JSR  HOSTINIT  Initialize host

         LDAA #$7f
         JSR  HOSTOUT   Send Delete to Altos
         LDAA #$0d
         JSR  HOSTOUT   Send <CR>
         INC  AUTOLF    Turn on Auto LF
         LDX  #INBUFF+5 Point at Load message
         STX  PTR0      Set pointer for load command
         LDY  #MSGEVB   Point at cat line
LOOP     LDAA 0,Y       Loop to xfer command line
         CMPA #04       Into buffalo line buffer
         BEQ  DONE      Quit on $04
         STAA 0,X
         INX            next character
         INY
         BRA  LOOP
DONE     CLR  TMP2      Set load vs. verify
         JSR  LOAD1B    Jmp into middle of load
         LDS  #STACK    Reset Stack
         JMP  $C0B3     Jump to Downloaded code

MSGEVB     FCC  /cat evbtest.out/
         FCB  $0D
         FCB  $04

        ORG     ROMBS+$1FA0
*** Jump table ***
.UPCASE JMP     UPCASE
.WCHEK  JMP     WCHEK
.DCHEK  JMP     DCHEK
.INIT   JMP     INIT
.INPUT  JMP     INPUT
.OUTPUT JMP     OUTPUT
.OUTLHL JMP     OUTLHLF
.OUTRHL JMP     OUTRHLF
.OUTA   JMP     OUTA
.OUT1BY JMP     OUT1BYT
.OUT1BS JMP     OUT1BSP
.OUT2BS JMP     OUT2BSP
.OUTCRL JMP     OUTCRLF
.OUTSTR JMP     OUTSTRG
.OUTST0 JMP     OUTSTRG0
.INCHAR JMP     INCHAR
.VECINT JMP    VECINIT

         ORG    ROMBS+$1FD6
*** Vectors ***
VSCI     FDB    JSCI
VSPI     FDB    JSPI
VPAIE    FDB    JPAIE
VPAO     FDB    JPAO
VTOF     FDB    JTOF
VTOC5    FDB    JTOC5
VTOC4    FDB    JTOC4
VTOC3    FDB    JTOC3
VTOC2    FDB    JTOC2
VTOC1    FDB    JTOC1
VTIC3    FDB    JTIC3
VTIC2    FDB    JTIC2
VTIC1    FDB    JTIC1
VRTI     FDB    JRTI
VIRQ     FDB    JIRQ
VXIRQ    FDB    JXIRQ
VSWI     FDB    JSWI
VILLOP   FDB    JILLOP
VCOP     FDB    JCOP
VCLM     FDB    JCLM
VRST     FDB    BUFFALO